# rust_name | signature | origin | receiver  (generated from the Rust sources by tools/sigs-from-rust.py)
accepts_void | pub(crate) fn accepts_void(t: P<Type>) -> bool | checker.go:9371 | -
active_mapper_cache_key | fn active_mapper_cache_key(t: P<Type>, alias: Option<P<TypeAlias>>) -> CacheHashKey | rust:checker_11.rs:1116 | -
add | pub fn add(&self, reference: P<Type>) | rust:types.rs:2286 | ReferenceInstantiations
add | pub(crate) fn add(&mut self, c: &mut Checker, t: P<Type>, info: TupleElementInfo) | checker.go:23891 | TupleNormalizer
add | pub(crate) fn add(&mut self, value: T) | utilities.go:892 | orderedSet
add_approximate_length | fn add_approximate_length(b: &NodeBuilderImpl, n: usize) | rust:nodebuilderimpl_2.rs:14 | -
add_class_modifiers | pub(crate) fn add_class_modifiers(&self, _c: &mut Checker, members: &mut [P<Node>], is_static: bool) -> Vec<P<Node>> | nodebuilder_hover.go:187 | NodeBuilderImpl
add_declaration_to_late_bound_symbol | pub(crate) fn add_declaration_to_late_bound_symbol(&mut self, symbol: P<Symbol>, member: P<Node>, symbol_flags: SymbolFlags) | checker.go:16419 | Checker
add_deferred_diagnostic | pub(crate) fn add_deferred_diagnostic(&mut self, callback: impl FnOnce(&mut Checker) + 'static) | checker.go:14210 | Checker
add_deprecated_suggestion | pub(crate) fn add_deprecated_suggestion(&mut self, location: P<Node>, declarations: &[P<Node>], deprecated_entity: &str) -> P<Diagnostic> | checker.go:14273 | Checker
add_deprecated_suggestion_with_signature | pub(crate) fn add_deprecated_suggestion_with_signature(&mut self, location: P<Node>, declaration: P<Node>, deprecated_entity: &str, signature_string: &str) -> P<Diagnostic> | checker.go:8549 | Checker
add_deprecated_suggestion_worker | pub(crate) fn add_deprecated_suggestion_worker(&mut self, declarations: &[P<Node>], diagnostic: P<Diagnostic>) -> P<Diagnostic> | checker.go:14278 | Checker
add_diagnostic | pub(crate) fn add_diagnostic(&mut self, diagnostic: P<Diagnostic>) -> P<Diagnostic> | checker.go:14221 | Checker
add_duplicate_declaration_error | pub(crate) fn add_duplicate_declaration_error(&mut self, node: P<Node>, message: &'static Message, symbol_name: &str, related_nodes: &[P<Node>]) | checker.go:14467 | Checker
add_duplicate_declaration_errors_for_symbols | pub(crate) fn add_duplicate_declaration_errors_for_symbols(&mut self, target: P<Symbol>, message: &'static Message, symbol_name: &str, source: P<Symbol>) | checker.go:14461 | Checker
add_error_or_suggestion | pub(crate) fn add_error_or_suggestion(&mut self, is_error: bool, diagnostic: P<Diagnostic>) | checker.go:14259 | Checker
add_evolving_array_element_type | pub(crate) fn add_evolving_array_element_type(&mut self, evolving_array_type: P<Type>, node: P<Node>) -> P<Type> | flow.go:1557 | Checker
add_file_with_target | fn add_file_with_target(&mut self, target: P<Symbol>, file: u32) | rust:printer.rs:1650 | ModuleExportIndex
add_flags | pub(crate) fn add_flags(&mut self, flags: u8) | rust:flowmemo.rs:285 | FlowMemo
add_implementation_success_elaboration | pub(crate) fn add_implementation_success_elaboration(&mut self, s: &CallState, failed: P<Signature>, diagnostic: P<Diagnostic>) | checker.go:9877 | Checker
add_inherited_members | pub(crate) fn add_inherited_members(symbols: Option<P<SymbolTable>>, base_symbols: &[P<Symbol>]) -> Option<P<SymbolTable>> | checker.go:19939 | Checker
add_intra_expression_inference_site | pub(crate) fn add_intra_expression_inference_site(n: P<InferenceContext>, node: P<Node>, t: P<Type>) | inference.go:1285 | Checker
add_named_unions | pub(crate) fn add_named_unions(named_unions: &[P<Type>], types: &[P<Type>]) -> Vec<P<Type>> | checker.go:26294 | Checker
add_optional_type_marker | pub(crate) fn add_optional_type_marker(&mut self, t: P<Type>) -> P<Type> | checker.go:20949 | Checker
add_optionality | pub(crate) fn add_optionality(&mut self, t: P<Type>) -> P<Type> | checker.go:18973 | Checker
add_optionality_ex | pub(crate) fn add_optionality_ex(&mut self, t: P<Type>, is_property: bool, is_optional: bool) -> P<Type> | checker.go:18977 | Checker
add_piece_diagnostics | pub fn add_piece_diagnostics(&mut self, source_file: P<SourceFile>, diagnostics: &[P<Diagnostic>], suggestions: &[P<Diagnostic>]) | rust:checker_02.rs:184 | Checker
add_property_to_element_list | pub(crate) fn add_property_to_element_list(&self, c: &mut Checker, property_symbol: P<Symbol>, type_elements: &[P<Node>]) -> Vec<P<Node>> | nodebuilderimpl.go:2578 | NodeBuilderImpl
add_reference_kinds | pub fn add_reference_kinds(&mut self, symbol: P<Symbol>, meaning: SymbolFlags) | rust:links.rs:328 | SymbolReferenceLinkStore
add_stat | fn add_stat(e: &mut Stat, s: &Stat) | rust:workcensus.rs:608 | -
add_suggestion_diagnostic | pub(crate) fn add_suggestion_diagnostic(&mut self, diagnostic: P<Diagnostic>) -> P<Diagnostic> | checker.go:14229 | Checker
add_symbol_type_to_context | pub(crate) fn add_symbol_type_to_context(&self, _c: &mut Checker, symbol: P<Symbol>, t: P<Type>) -> Box<dyn FnMut(&mut Checker)> | nodebuilderscopes.go:40 | NodeBuilderImpl
add_template_spans | fn add_template_spans(c: &mut Checker, state: &mut TemplateSpansState, texts: &[&str], types: &[P<Type>]) -> bool | checker.go:29645 | -
add_to_dotted_name | pub(crate) fn add_to_dotted_name(head: &str, tail: &str) -> String | relater.go:4912 | -
add_type_only_declaration_related_info | pub(crate) fn add_type_only_declaration_related_info(diagnostic: P<Diagnostic>, type_only_declaration: Option<P<Node>>, name: &str) -> P<Diagnostic> | checker.go:2209 | Checker
add_type_to_intersection | pub(crate) fn add_type_to_intersection(&mut self, type_set: &mut orderedSet<P<Type>>, includes: TypeFlags, t: P<Type>) -> TypeFlags | checker.go:26728 | Checker
add_types_to_intersection | pub(crate) fn add_types_to_intersection(&mut self, type_set: &mut orderedSet<P<Type>>, includes: TypeFlags, types: &[P<Type>]) -> TypeFlags | checker.go:26721 | Checker
add_types_to_union | pub(crate) fn add_types_to_union(&mut self, source_types: &[P<Type>]) -> (Vec<P<Type>>, TypeFlags) | checker.go:26231 | Checker
add_undefined_to_globals_or_error_on_redeclaration | pub(crate) fn add_undefined_to_globals_or_error_on_redeclaration(&mut self) | checker.go:1493 | Checker
address | fn address(key: P<K>) -> PKey | rust:links.rs:57 | LinkStore
alias | pub fn alias(self) -> Option<P<TypeAlias>> | rust:types.rs:1167 | AliasArg
alias | pub fn alias(&self) -> Option<P<TypeAlias>> | rust:types.rs:1689 | Type
alias_marking_visitor_worker | pub(crate) fn alias_marking_visitor_worker(&self, c: &mut Checker, node: P<Node>) -> bool | emitresolver.go:260 | EmitResolver
all_declarations_in_same_source_file | pub(crate) fn all_declarations_in_same_source_file(symbol: P<Symbol>) -> bool | utilities.go:1633 | -
all_types_assignable_to_kind | pub(crate) fn all_types_assignable_to_kind(&mut self, source: P<Type>, kind: TypeFlags) -> bool | checker.go:28098 | Checker
all_types_assignable_to_kind_ex | pub(crate) fn all_types_assignable_to_kind_ex(&mut self, source: P<Type>, kind: TypeFlags, strict: bool) -> bool | checker.go:28102 | Checker
alloc | pub(crate) fn alloc<T: TypePayload>(flags: TypeFlags, object_flags: ObjectFlags, id: TypeId, data: T) -> P<Type> | rust:types.rs:1402 | Type
alloc_rare | fn alloc_rare(rare: RareTypeMapper) -> P<TypeMapper> | rust:mapper.rs:216 | TypeMapper
any_to_string | pub fn any_to_string(v: LiteralValue) -> String | rust:evaluator.rs:143 | -
append_contextual_property_type_constituent | pub(crate) fn append_contextual_property_type_constituent(&self, types: &mut Vec<P<Type>>, t: Option<P<Type>>) | checker.go:31160 | Checker
append_index_info | pub(crate) fn append_index_info(&mut self, index_infos: &mut [P<IndexInfo>], new_info: P<IndexInfo>, union: bool) -> Vec<P<IndexInfo>> | checker.go:21687 | Checker
append_inherited_signatures_and_index_infos | pub(crate) fn append_inherited_signatures_and_index_infos(&mut self, call_signatures: &mut Vec<P<Signature>>, construct_signatures: &mut Vec<P<Signature>>, index_infos: &mut Vec<P<IndexInfo>>, base_type: P<Type>) | rust:checker_09.rs:2815 | Checker
append_local_type_parameters_of_class_or_interface_or_type_alias | pub(crate) fn append_local_type_parameters_of_class_or_interface_or_type_alias(&mut self, types: &[P<Type>], symbol: P<Symbol>) -> Vec<P<Type>> | checker.go:24280 | Checker
append_mapped_type_index_info | pub(crate) fn append_mapped_type_index_info(&mut self, index_infos: Vec<P<IndexInfo>>, t: P<Type>, modifiers_type: P<Type>, type_parameter: P<Type>, template_type: P<Type>, template_modifiers: MappedTypeModifiers, key_type: P<Type>, prop_name_type: P<Type>) -> Vec<P<IndexInfo>> | rust:checker_10.rs:2016 | Checker
append_reference_to_type | pub(crate) fn append_reference_to_type(&self, c: &mut Checker, root: P<Node>, ref_: P<Node>) -> P<Node> | nodebuilderimpl.go:272 | NodeBuilderImpl
append_signatures | pub(crate) fn append_signatures(&mut self, signatures: &[P<Signature>], new_signatures: &[P<Signature>]) -> Vec<P<Signature>> | checker.go:21676 | Checker
append_type_mapping | pub(crate) fn append_type_mapping(mapper: Option<P<TypeMapper>>, source: P<Type>, target: P<Type>) -> P<TypeMapper> | rust:mapper.rs:505 | -
append_type_parameters | pub(crate) fn append_type_parameters(&mut self, type_parameters: &[P<Type>], declarations: &[P<Node>]) -> Vec<P<Type>> | checker.go:24292 | Checker
apply_string_mapping | pub(crate) fn apply_string_mapping(symbol: P<Symbol>, str: &str) -> String | checker.go:29731 | -
apply_target_string_mapping_to_source | pub(crate) fn apply_target_string_mapping_to_source(&mut self, source: P<Type>, target: P<Type>) -> (P<Type>, P<Type>) | relater.go:2551 | Checker
apply_template_string_mapping | pub(crate) fn apply_template_string_mapping(&mut self, symbol: P<Symbol>, texts: &[&str], types: &[P<Type>]) -> (Vec<String>, Vec<P<Type>>) | checker.go:29747 | Checker
apply_to_parameter_types | pub(crate) fn apply_to_parameter_types(&mut self, source: P<Signature>, target: P<Signature>, callback: impl FnMut(&mut Checker, P<Type>, P<Type>)) | inference.go:868 | Checker
apply_to_return_types | pub(crate) fn apply_to_return_types(&mut self, source: P<Signature>, target: P<Signature>, callback: impl FnMut(&mut Checker, P<Type>, P<Type>)) | inference.go:896 | Checker
are_all_outer_type_parameters_applied | pub(crate) fn are_all_outer_type_parameters_applied(&mut self, t: P<Type>) -> bool | checker.go:19861 | Checker
are_declaration_flags_identical | pub(crate) fn are_declaration_flags_identical(left: P<Node>, right: P<Node>) -> bool | checker.go:7036 | Checker
are_different_plain_literals | pub(crate) fn are_different_plain_literals(a: P<Type>, b: P<Type>) -> bool | rust:relater_1.rs:3634 | -
are_properties_abstract_or_interface | pub(crate) fn are_properties_abstract_or_interface(base: P<Symbol>, base_declaration_flags: ModifierFlags) -> bool | checker.go:4744 | Checker
are_type_parameters_identical | pub(crate) fn are_type_parameters_identical(&mut self, declarations: &[P<Node>], target_parameters: &[P<Type>], get_type_parameter_declarations: impl FnMut(&mut Checker, P<Node>) -> Vec<P<Node>>) -> bool | checker.go:4501 | Checker
are_types_comparable | pub(crate) fn are_types_comparable(&mut self, type1: P<Type>, type2: P<Type>) -> bool | relater.go:165 | Checker
arguments_of | fn arguments_of(reference: P<Type>) -> &'static [P<Type>] | rust:types.rs:2268 | ReferenceInstantiations
array_is_homogeneous | pub(crate) fn array_is_homogeneous<T: Clone>(array: &[T], comparer: impl FnMut(T, T) -> bool) -> bool | nodebuilderimpl.go:467 | -
array_sources_targets | pub fn array_sources_targets(&self) -> Option<(&'static [P<Type>], &'static [P<Type>])> | rust:mapper.rs:136 | TypeMapperData
as_conditional_type | pub fn as_conditional_type(&self) -> &'static ConditionalType | rust:types.rs:1555 | Type
as_constrained_type | pub fn as_constrained_type(&self) -> &'static ConstrainedType | rust:types.rs:1563 | Type
as_constrained_type | pub fn as_constrained_type(&self) -> Option<&'static ConstrainedType> | rust:types.rs:1852 | TypeData
as_evolving_array_type | pub fn as_evolving_array_type(&self) -> &'static EvolvingArrayType | rust:types.rs:1510 | Type
as_index_type | pub fn as_index_type(&self) -> &'static IndexType | rust:types.rs:1530 | Type
as_indexed_access_type | pub fn as_indexed_access_type(&self) -> &'static IndexedAccessType | rust:types.rs:1535 | Type
as_instantiation_expression_type | pub fn as_instantiation_expression_type(&self) -> &'static InstantiationExpressionType | rust:types.rs:1495 | Type
as_interface_type | pub fn as_interface_type(&self) -> &'static InterfaceType | rust:types.rs:1579 | Type
as_interface_type | pub fn as_interface_type(&self) -> Option<&'static InterfaceType> | rust:types.rs:1918 | TypeData
as_intersection_type | pub fn as_intersection_type(&self) -> &'static IntersectionType | rust:types.rs:1525 | Type
as_intrinsic_type | pub fn as_intrinsic_type(&self) -> &'static IntrinsicType | rust:types.rs:1475 | Type
as_literal_type | pub fn as_literal_type(&self) -> &'static LiteralType | rust:types.rs:1480 | Type
as_mapped_type | pub fn as_mapped_type(&self) -> &'static MappedType | rust:types.rs:1500 | Type
as_object_type | pub fn as_object_type(&self) -> &'static ObjectType | rust:types.rs:1571 | Type
as_object_type | pub fn as_object_type(&self) -> Option<&'static ObjectType> | rust:types.rs:1893 | TypeData
as_p | fn as_p(&self) -> P<InferenceContext> | rust:checker.rs:356 | InferenceContext
as_p | pub fn as_p(&self) -> P<NodeBuilderImpl> | rust:nodebuilder_types.rs:201 | NodeBuilderImpl
as_p | pub fn as_p(&self) -> P<Relater> | rust:relater_types.rs:237 | Relater
as_recursion_id | pub(crate) fn as_recursion_id<T: Into<RecursionId>>(value: T) -> RecursionId | relater.go:94 | -
as_reverse_mapped_type | pub fn as_reverse_mapped_type(&self) -> &'static ReverseMappedType | rust:types.rs:1505 | Type
as_string_mapping_type | pub fn as_string_mapping_type(&self) -> &'static StringMappingType | rust:types.rs:1545 | Type
as_structured_type | pub fn as_structured_type(&self) -> &'static StructuredType | rust:types.rs:1567 | Type
as_structured_type | pub fn as_structured_type(&self) -> Option<&'static StructuredType> | rust:types.rs:1876 | TypeData
as_substitution_type | pub fn as_substitution_type(&self) -> &'static SubstitutionType | rust:types.rs:1550 | Type
as_template_literal_type | pub fn as_template_literal_type(&self) -> &'static TemplateLiteralType | rust:types.rs:1540 | Type
as_tuple_type | pub fn as_tuple_type(&self) -> &'static TupleType | rust:types.rs:1490 | Type
as_type_parameter | pub fn as_type_parameter(&self) -> &'static TypeParameter | rust:types.rs:1515 | Type
as_type_reference | pub fn as_type_reference(&self) -> &'static TypeReference | rust:types.rs:1575 | Type
as_type_reference | pub fn as_type_reference(&self) -> Option<&'static TypeReference> | rust:types.rs:1908 | TypeData
as_union_or_intersection_type | pub fn as_union_or_intersection_type(&self) -> &'static UnionOrIntersectionType | rust:types.rs:1583 | Type
as_union_or_intersection_type | pub fn as_union_or_intersection_type(&self) -> Option<&'static UnionOrIntersectionType> | rust:types.rs:1927 | TypeData
as_union_type | pub fn as_union_type(&self) -> &'static UnionType | rust:types.rs:1520 | Type
as_unique_es_symbol_type | pub fn as_unique_es_symbol_type(&self) -> &'static UniqueESSymbolType | rust:types.rs:1485 | Type
assert_freezable | pub fn assert_freezable(&self) | rust:checker.rs:2365 | Checker
assign | pub fn assign(&self, m: FxHashMap<K, V>) | rust:types.rs:165 | GoMap
assign_binding_element_types | pub(crate) fn assign_binding_element_types(&mut self, pattern: P<Node>, parent_type: P<Type>) | checker.go:10627 | Checker
assign_contextual_parameter_types | pub(crate) fn assign_contextual_parameter_types(&mut self, sig: P<Signature>, context: P<Signature>) | checker.go:10546 | Checker
assign_non_contextual_parameter_types | pub(crate) fn assign_non_contextual_parameter_types(&mut self, signature: P<Signature>) | checker.go:10592 | Checker
assign_parameter_type | pub(crate) fn assign_parameter_type(&mut self, parameter: P<Symbol>, contextual_type: Option<P<Type>>) | checker.go:10601 | Checker
at | fn at(&self, slot: u32) -> P<V> | rust:links.rs:412 | IdLinkStore
at | fn at(&self, index: u32) -> P<V> | rust:links.rs:62 | LinkStore
attach_symbol_to_leftmost_identifier | fn attach_symbol_to_leftmost_identifier(self, c: &mut Checker, leftmost: P<Node>, node: P<Node>, sym: Option<P<Symbol>>) -> P<Node> | rust:nodecopy.rs:405 | ExistingNodeTree
attach_symbol_visitor_func | fn attach_symbol_visitor_func(self, c: &mut Checker, vis: &mut NodeVisitor, leftmost: P<Node>, sym: Option<P<Symbol>>, node: P<Node>) -> P<Node> | rust:nodecopy.rs:413 | ExistingNodeTree
base | pub fn base(&self) -> Option<&'static M> | rust:basedmap.rs:34 | Based
base_get | pub fn base_get(&self, key: &K) -> Option<&'static V> | rust:basedmap.rs:72 | Based
base_type | pub fn base_type(&self) -> Option<P<Type>> | rust:types.rs:2865 | SubstitutionType
begin | pub fn begin(&mut self, cat: Cat, key: CKey) -> Span | rust:workcensus.rs:243 | Census
begin | fn begin(&mut self, instantiation_count: u32, total_instantiation_count: u32, created: u32, in_instantiation: bool) -> FlowFrame | rust:flowmemo.rs:231 | FlowMemo
bind_element | fn bind_element(b: &NodeBuilderImpl, c: &mut Checker, e: P<Node>, add: AddSymbol) | rust:nodebuilderscopes.rs:238 | -
bind_pattern | fn bind_pattern(b: &NodeBuilderImpl, c: &mut Checker, p: P<Node>, add: AddSymbol) | rust:nodebuilderscopes.rs:225 | -
bits | fn bits() -> u32 | rust:unioncache.rs:95 | -
bits | const fn bits(self) -> Option<u32> | rust:checker.rs:656 | InferencePriority
both_are_big_int_like | pub(crate) fn both_are_big_int_like(&mut self, left: P<Type>, right: P<Type>) -> bool | checker.go:12991 | Checker
bucket | pub(crate) fn bucket(n: usize) -> u32 | rust:workcensus.rs:176 | -
bucket_label | fn bucket_label(b: u32) -> String | rust:workcensus.rs:184 | -
build_augment_filter | fn build_augment_filter(&mut self, key: HashedName<'_>) -> bool | rust:checker_09.rs:2438 | Checker
build_feature_map | fn build_feature_map() -> FxHashMap<&'static str, Vec<FeatureMapEntry>> | rust:utilities_types.rs:45 | -
cached_type_of_value_symbol | pub(crate) fn cached_type_of_value_symbol(&self, symbol: P<Symbol>) -> Option<P<Type>> | rust:checker_08.rs:1753 | Checker
call_like_expression_may_have_type_arguments | pub(crate) fn call_like_expression_may_have_type_arguments(node: P<Node>) -> bool | utilities.go:1132 | Checker
call_signature_count | fn call_signature_count(&self) -> usize | rust:types.rs:2079 | CountOrIndexInfos
call_signature_count | pub fn call_signature_count(&self) -> usize | rust:types.rs:2150 | StructuredType
call_signatures | pub fn call_signatures(&self) -> &'static [P<Signature>] | rust:types.rs:2170 | StructuredType
can_get_type_parameters_of_class_or_interface | pub(crate) fn can_get_type_parameters_of_class_or_interface(symbol: P<Symbol>) -> bool | checker.go:24221 | Checker
can_have_locals | pub(crate) fn can_have_locals(node: P<Node>) -> bool | utilities.go:183 | -
can_have_module_specifier | pub(crate) fn can_have_module_specifier(node: Option<P<Node>>) -> bool | nodebuilderimpl.go:1172 | -
can_have_synthetic_default | pub(crate) fn can_have_synthetic_default(&mut self, file: Option<P<Node>>, module_symbol: P<Symbol>, dont_resolve_alias: bool, usage: P<Node>) -> bool | checker.go:15061 | Checker
can_qualify_symbol | pub(crate) fn can_qualify_symbol(&mut self, ctx: &accessibleSymbolChainContext, symbol_from_symbol_table: P<Symbol>, meaning: SymbolFlags) -> bool | symbolaccessibility.go:677 | Checker
can_reuse_existing_js_type_node | pub(crate) fn can_reuse_existing_js_type_node(c: &mut Checker, existing: P<Node>, t: P<Type>) -> bool | nodebuilderimpl.go:507 | NodeBuilderImpl
can_use_property_access | pub(crate) fn can_use_property_access(name: &str) -> bool | nodebuilderimpl.go:912 | -
candidates | fn candidates(&self, target: P<Symbol>) -> impl Iterator<Item = P<Symbol>> + '_ | rust:printer.rs:1683 | ExportsByTarget
canonicalize_base_type_cycles | fn canonicalize_base_type_cycles(&mut self, t: P<Type>) | rust:checker_09.rs:3336 | Checker
capacity | pub fn capacity(&self) -> usize | rust:packedmap.rs:106 | PackedMap
census_begin | pub(crate) fn census_begin(&mut self, cat: Cat, key: impl FnOnce() -> CKey) -> Option<Span> | rust:workcensus.rs:525 | Checker
census_collect | pub fn census_collect(&mut self) | rust:workcensus.rs:538 | Checker
census_enabled | pub fn census_enabled() -> bool | rust:workcensus.rs:500 | Checker
census_end | pub(crate) fn census_end(&mut self, span: Option<Span>) -> Option<Timing> | rust:workcensus.rs:530 | Checker
census_mut | pub(crate) fn census_mut(&mut self) -> Option<&mut Census> | rust:workcensus.rs:516 | Checker
census_on | pub(crate) fn census_on(&self) -> bool | rust:workcensus.rs:511 | Checker
census_path | pub fn census_path() -> Option<&'static str> | rust:workcensus.rs:31 | -
census_report | pub fn census_report() | rust:workcensus.rs:624 | -
census_write_report | pub fn census_write_report() | rust:workcensus.rs:504 | Checker
chain_args_match | pub(crate) fn chain_args_match(&self, _c: &mut Checker, args: &[Option<&str>]) -> bool | relater.go:4950 | Relater
chain_depth | pub(crate) fn chain_depth(chain: Option<P<ErrorChain>>) -> usize | relater.go:4976 | -
charge_bookkeeping | pub fn charge_bookkeeping(&mut self) | rust:workcensus.rs:296 | Census
charge_since | pub fn charge_since(&mut self, t0: u64) | rust:workcensus.rs:312 | Census
check_accessor_declaration | pub(crate) fn check_accessor_declaration(&mut self, node: P<Node>) | checker.go:2976 | Checker
check_alias_symbol | pub(crate) fn check_alias_symbol(&mut self, node: P<Node>) | checker.go:6906 | Checker
check_all_code_paths_in_non_void_function_return_or_throw | pub(crate) fn check_all_code_paths_in_non_void_function_return_or_throw(&mut self, fn_: P<Node>, return_type: Option<P<Type>>) | checker.go:3756 | Checker
check_ambient_initializer | pub(crate) fn check_ambient_initializer(&mut self, node: P<Node>) -> bool | grammarchecks.go:1925 | Checker
check_and_aggregate_return_expression_types | pub(crate) fn check_and_aggregate_return_expression_types(&mut self, fn_: P<Node>, check_mode: CheckMode) -> (Vec<P<Type>>, bool) | checker.go:20600 | Checker
check_and_aggregate_yield_operand_types | pub(crate) fn check_and_aggregate_yield_operand_types(&mut self, fn_: P<Node>, check_mode: CheckMode) -> (Vec<P<Type>>, Vec<P<Type>>) | checker.go:20663 | Checker
check_and_report_error_for_exporting_primitive_type | pub(crate) fn check_and_report_error_for_exporting_primitive_type(&mut self, error_location: P<Node>, name: &str) -> bool | checker.go:1670 | Checker
check_and_report_error_for_extending_interface | pub(crate) fn check_and_report_error_for_extending_interface(&mut self, error_location: P<Node>) -> bool | checker.go:11867 | Checker
check_and_report_error_for_invalid_initializer | pub(crate) fn check_and_report_error_for_invalid_initializer(&mut self, error_location: Option<P<Node>>, name: &str, property_with_invalid_initializer: P<Node>, result: Option<P<Symbol>>) -> bool | checker.go:1555 | Checker
check_and_report_error_for_missing_prefix | pub(crate) fn check_and_report_error_for_missing_prefix(&mut self, error_location: P<Node>, name: &str) -> bool | checker.go:1573 | Checker
check_and_report_error_for_resolving_import_alias_to_type_only_symbol | pub(crate) fn check_and_report_error_for_resolving_import_alias_to_type_only_symbol(&mut self, node: P<Node>, _resolved: Option<P<Symbol>>) | checker.go:14723 | Checker
check_and_report_error_for_using_namespace_as_type_or_value | pub(crate) fn check_and_report_error_for_using_namespace_as_type_or_value(&mut self, error_location: P<Node>, name: &str, meaning: SymbolFlags) -> bool | checker.go:1682 | Checker
check_and_report_error_for_using_type_as_namespace | pub(crate) fn check_and_report_error_for_using_type_as_namespace(&mut self, error_location: P<Node>, name: &str, meaning: SymbolFlags) -> bool | checker.go:1649 | Checker
check_and_report_error_for_using_type_as_value | pub(crate) fn check_and_report_error_for_using_type_as_value(&mut self, error_location: P<Node>, name: &str, meaning: SymbolFlags) -> bool | checker.go:1703 | Checker
check_and_report_error_for_using_value_as_type | pub(crate) fn check_and_report_error_for_using_value_as_type(&mut self, error_location: P<Node>, name: &str, meaning: SymbolFlags) -> bool | checker.go:1763 | Checker
check_applicable_signature_for_jsx_call_like_element | pub(crate) fn check_applicable_signature_for_jsx_call_like_element(&mut self, node: P<Node>, signature: P<Signature>, relation: P<Relation>, check_mode: CheckMode, report_errors: bool, diagnostic_output: Option<&mut Vec<P<Diagnostic>>>) -> bool | jsx.go:591 | Checker
check_arithmetic_operand_type | pub(crate) fn check_arithmetic_operand_type(&mut self, operand: P<Node>, t: P<Type>, diagnostic: &'static Message, is_await_valid: bool) -> bool | checker.go:13007 | Checker
check_array_literal | pub(crate) fn check_array_literal(&mut self, node: P<Node>, check_mode: CheckMode) -> P<Type> | checker.go:8193 | Checker
check_array_literal_assignment | pub(crate) fn check_array_literal_assignment(&mut self, node: P<Node>, source_type: P<Type>, check_mode: CheckMode) -> P<Type> | checker.go:12851 | Checker
check_array_literal_destructuring_element_assignment | pub(crate) fn check_array_literal_destructuring_element_assignment(&mut self, node: P<Node>, source_type: P<Type>, element_index: usize, element_type: P<Type>, check_mode: CheckMode) -> Option<P<Type>> | checker.go:12871 | Checker
check_array_type | pub(crate) fn check_array_type(&mut self, node: P<Node>) | checker.go:3277 | Checker
check_assertion | pub(crate) fn check_assertion(&mut self, node: P<Node>, check_mode: CheckMode) -> P<Type> | checker.go:12490 | Checker
check_assertion_deferred | pub(crate) fn check_assertion_deferred(&mut self, node: P<Node>) | checker.go:12518 | Checker
check_assignment_operator | pub(crate) fn check_assignment_operator(&mut self, left: P<Node>, operator: Kind, right: P<Node>, left_type: P<Type>, right_type: P<Type>) | checker.go:12965 | Checker
check_async_function_return_type | pub(crate) fn check_async_function_return_type(&mut self, node: P<Node>, return_type_node: P<Node>) | checker.go:2825 | Checker
check_await_expression | pub(crate) fn check_await_expression(&mut self, node: P<Node>) -> P<Type> | checker.go:11045 | Checker
check_awaited_type | pub(crate) fn check_awaited_type(&mut self, t: P<Type>, with_alias: bool, error_node: P<Node>, diagnostic_message: &'static Message) -> P<Type> | checker.go:31721 | Checker
check_base_type_accessibility | pub(crate) fn check_base_type_accessibility(&mut self, t: P<Type>, node: P<Node>) | checker.go:4538 | Checker
check_binary_expression | pub(crate) fn check_binary_expression(&mut self, node: P<Node>, check_mode: CheckMode) -> P<Type> | checker.go:12534 | Checker
check_binary_like_expression | pub(crate) fn check_binary_like_expression(&mut self, left: P<Node>, operator_token: P<Node>, right: P<Node>, check_mode: CheckMode, error_node: Option<P<Node>>) -> P<Type> | checker.go:12539 | Checker
check_binding_element | pub(crate) fn check_binding_element(&mut self, node: P<Node>) | checker.go:4301 | Checker
check_block | pub(crate) fn check_block(&mut self, node: P<Node>) | checker.go:3813 | Checker
check_break_or_continue_statement | pub(crate) fn check_break_or_continue_statement(&mut self, node: P<Node>) | checker.go:4108 | Checker
check_call_expression | pub(crate) fn check_call_expression(&mut self, node: P<Node>, check_mode: CheckMode) -> P<Type> | checker.go:8496 | Checker
check_catch_clause | pub(crate) fn check_catch_clause(&mut self, node: P<Node>) | checker.go:4275 | Checker
check_class_declaration | pub(crate) fn check_class_declaration(&mut self, node: P<Node>) | checker.go:4306 | Checker
check_class_expression | pub(crate) fn check_class_expression(&mut self, node: P<Node>) -> P<Type> | checker.go:10239 | Checker
check_class_expression_deferred | pub(crate) fn check_class_expression_deferred(&mut self, node: P<Node>) | checker.go:10301 | Checker
check_class_expression_external_helpers | pub(crate) fn check_class_expression_external_helpers(&mut self, node: P<Node>) | checker.go:10273 | Checker
check_class_for_static_property_name_conflicts | pub(crate) fn check_class_for_static_property_name_conflicts(&mut self, node: P<Node>) | checker.go:4450 | Checker
check_class_like_declaration | pub(crate) fn check_class_like_declaration(&mut self, node: P<Node>) | checker.go:4321 | Checker
check_class_name_collision_with_object | pub(crate) fn check_class_name_collision_with_object(&mut self, name: P<Node>) | checker.go:10808 | Checker
check_class_or_interface_for_duplicate_index_signatures | pub(crate) fn check_class_or_interface_for_duplicate_index_signatures(&mut self, node: P<Node>) | checker.go:4987 | Checker
check_class_static_block_declaration | pub(crate) fn check_class_static_block_declaration(&mut self, node: P<Node>) | checker.go:2861 | Checker
check_collision_with_global_object_in_generated_code | pub(crate) fn check_collision_with_global_object_in_generated_code(&mut self, node: P<Node>, name: Option<P<Node>>) | checker.go:10680 | Checker
check_collision_with_global_promise_in_generated_code | pub(crate) fn check_collision_with_global_promise_in_generated_code(&mut self, node: P<Node>, name: Option<P<Node>>) | checker.go:10755 | Checker
check_collision_with_require_exports_in_generated_code | pub(crate) fn check_collision_with_require_exports_in_generated_code(&mut self, node: P<Node>, name: Option<P<Node>>) | checker.go:10660 | Checker
check_collisions_for_declaration_name | pub(crate) fn check_collisions_for_declaration_name(&mut self, node: P<Node>, name: Option<P<Node>>) | checker.go:10641 | Checker
check_computed_property_name | pub(crate) fn check_computed_property_name(&mut self, node: P<Node>) -> P<Type> | checker.go:27272 | Checker
check_conditional_expression | pub(crate) fn check_conditional_expression(&mut self, node: P<Node>, check_mode: CheckMode) -> P<Type> | checker.go:11134 | Checker
check_conditional_type | pub(crate) fn check_conditional_type(&mut self, node: P<Node>) | checker.go:3332 | Checker
check_const_enum_access | pub(crate) fn check_const_enum_access(&mut self, node: P<Node>, t: P<Type>) | checker.go:7745 | Checker
check_constructor_declaration | pub(crate) fn check_constructor_declaration(&mut self, node: P<Node>) | checker.go:2870 | Checker
check_contextual_deprecations | pub(crate) fn check_contextual_deprecations(&mut self, node: P<Node>) | checker.go:13564 | Checker
check_cross_product_union | pub(crate) fn check_cross_product_union(&mut self, types: &[P<Type>], key: u64) -> bool | checker.go:27118 | Checker
check_declaration_initializer | pub(crate) fn check_declaration_initializer(&mut self, declaration: P<Node>, check_mode: CheckMode, contextual_type: Option<P<Type>>) -> P<Type> | checker.go:17120 | Checker
check_decorator | pub(crate) fn check_decorator(&mut self, node: P<Node>) | checker.go:6231 | Checker
check_decorators | pub(crate) fn check_decorators(&mut self, node: P<Node>) | checker.go:6192 | Checker
check_deferred_node | pub(crate) fn check_deferred_node(&mut self, node: P<Node>) | checker.go:2544 | Checker
check_deferred_nodes | pub(crate) fn check_deferred_nodes(&mut self, context: P<SourceFile>) | checker.go:2533 | Checker
check_delete_expression | pub(crate) fn check_delete_expression(&mut self, node: P<Node>) -> P<Type> | checker.go:11004 | Checker
check_delete_expression_must_be_optional | pub(crate) fn check_delete_expression_must_be_optional(&mut self, expr: P<Node>, symbol: P<Symbol>) | checker.go:11025 | Checker
check_deprecated_property | pub(crate) fn check_deprecated_property(&mut self, name: P<Node>, contextual_type: Option<P<Type>>) | checker.go:13576 | Checker
check_deprecated_signature | pub(crate) fn check_deprecated_signature(&mut self, sig: P<Signature>, node: P<Node>) | checker.go:8538 | Checker
check_destructuring_assignment | pub(crate) fn check_destructuring_assignment(&mut self, node: P<Node>, source_type: P<Type>, check_mode: CheckMode, right_is_this: bool) -> P<Type> | checker.go:12755 | Checker
check_do_statement | pub(crate) fn check_do_statement(&mut self, node: P<Node>) | checker.go:3975 | Checker
check_element_access_chain | pub(crate) fn check_element_access_chain(&mut self, node: P<Node>, check_mode: CheckMode) -> P<Type> | checker.go:8312 | Checker
check_element_access_expression | pub(crate) fn check_element_access_expression(&mut self, node: P<Node>, expr_type: P<Type>, check_mode: CheckMode) -> P<Type> | checker.go:8318 | Checker
check_enum_declaration | pub(crate) fn check_enum_declaration(&mut self, node: P<Node>) | checker.go:5163 | Checker
check_enum_member | pub(crate) fn check_enum_member(&mut self, node: P<Node>) | checker.go:5214 | Checker
check_export_assignment | pub(crate) fn check_export_assignment(&mut self, node: P<Node>) | checker.go:5748 | Checker
check_export_declaration | pub(crate) fn check_export_declaration(&mut self, node: P<Node>) | checker.go:5653 | Checker
check_export_specifier | pub(crate) fn check_export_specifier(&mut self, node: P<Node>) | checker.go:5716 | Checker
check_exports_on_merged_declarations | pub(crate) fn check_exports_on_merged_declarations(&mut self, node: P<Node>) | checker.go:7082 | Checker
check_expression | pub(crate) fn check_expression(&mut self, node: P<Node>) -> P<Type> | checker.go:7725 | Checker
check_expression_cached | pub(crate) fn check_expression_cached(&mut self, node: P<Node>) -> P<Type> | checker.go:7685 | Checker
check_expression_cached_ex | pub(crate) fn check_expression_cached_ex(&mut self, node: P<Node>, check_mode: CheckMode) -> P<Type> | checker.go:7689 | Checker
check_expression_ex | pub(crate) fn check_expression_ex(&mut self, node: P<Node>, check_mode: CheckMode) -> P<Type> | checker.go:7729 | Checker
check_expression_for_mutable_location | pub(crate) fn check_expression_for_mutable_location(&mut self, node: P<Node>, check_mode: CheckMode) -> P<Type> | checker.go:14113 | Checker
check_expression_for_mutable_location_with_contextual_type | pub(crate) fn check_expression_for_mutable_location_with_contextual_type(&mut self, next: P<Node>, source_prop_type: P<Type>) -> P<Type> | relater.go:632 | Checker
check_expression_statement | pub(crate) fn check_expression_statement(&mut self, node: P<Node>) | checker.go:7501 | Checker
check_expression_with_contextual_type | pub(crate) fn check_expression_with_contextual_type(&mut self, node: P<Node>, contextual_type: P<Type>, inference_context: Option<P<InferenceContext>>, check_mode: CheckMode) -> P<Type> | checker.go:7656 | Checker
check_expression_with_contextual_type_worker | fn check_expression_with_contextual_type_worker(&mut self, node: P<Node>, contextual_type: P<Type>, inference_context: Option<P<InferenceContext>>, check_mode: CheckMode) -> P<Type> | rust:checker_04.rs:1443 | Checker
check_expression_with_type_arguments | pub(crate) fn check_expression_with_type_arguments(&mut self, node: P<Node>) -> P<Type> | checker.go:10834 | Checker
check_expression_worker | pub(crate) fn check_expression_worker(&mut self, node: P<Node>, check_mode: CheckMode) -> P<Type> | checker.go:7903 | Checker
check_external_emit_helpers | pub(crate) fn check_external_emit_helpers(&mut self, location: P<Node>, helpers: ExternalEmitHelpers) | checker.go:29046 | Checker
check_external_import_or_export_declaration | pub(crate) fn check_external_import_or_export_declaration(&mut self, node: P<Node>) -> bool | checker.go:5467 | Checker
check_external_module_exports | pub(crate) fn check_external_module_exports(&mut self, node: P<Node>) | checker.go:5858 | Checker
check_external_module_name_in_global_scope | pub(crate) fn check_external_module_name_in_global_scope(&mut self, node: P<Node>) | checker.go:5702 | Checker
check_for_disallowed_es_symbol_operand | pub(crate) fn check_for_disallowed_es_symbol_operand(&mut self, left: P<Node>, right: P<Node>, left_type: P<Type>, right_type: P<Type>, operator: Kind) -> bool | checker.go:13020 | Checker
check_for_in_statement | pub(crate) fn check_for_in_statement(&mut self, node: P<Node>) | checker.go:4013 | Checker
check_for_of_statement | pub(crate) fn check_for_of_statement(&mut self, node: P<Node>) | checker.go:4060 | Checker
check_for_statement | pub(crate) fn check_for_statement(&mut self, node: P<Node>) | checker.go:3987 | Checker
check_function_declaration | pub(crate) fn check_function_declaration(&mut self, node: P<Node>) | checker.go:3431 | Checker
check_function_expression_or_object_literal_method | pub(crate) fn check_function_expression_or_object_literal_method(&mut self, node: P<Node>, check_mode: CheckMode) -> P<Type> | checker.go:10306 | Checker
check_function_expression_or_object_literal_method_deferred | pub(crate) fn check_function_expression_or_object_literal_method_deferred(&mut self, node: P<Node>) | checker.go:10403 | Checker
check_function_or_constructor_symbol | pub(crate) fn check_function_or_constructor_symbol(&mut self, symbol: P<Symbol>) | checker.go:3489 | Checker
check_function_or_constructor_symbol_worker | pub(crate) fn check_function_or_constructor_symbol_worker(&mut self, symbol: P<Symbol>) | checker.go:3497 | Checker
check_function_or_method_declaration | pub(crate) fn check_function_or_method_declaration(&mut self, node: P<Node>) | checker.go:3437 | Checker
check_generator_instantiation_assignability_to_return_type | pub(crate) fn check_generator_instantiation_assignability_to_return_type(&mut self, return_type: P<Type>, function_flags: FunctionFlags, error_node: Option<P<Node>>) -> bool | checker.go:30186 | Checker
check_grammar_accessor | pub(crate) fn check_grammar_accessor(&mut self, accessor: P<Node>) -> bool | grammarchecks.go:1289 | Checker
check_grammar_arrow_function | pub(crate) fn check_grammar_arrow_function(&mut self, node: P<Node>, file: P<SourceFile>) -> bool | grammarchecks.go:772 | Checker
check_grammar_async_modifier | pub(crate) fn check_grammar_async_modifier(&mut self, node: P<Node>, async_modifier: Option<P<Node>>) -> bool | grammarchecks.go:659 | Checker
check_grammar_await_or_await_using | pub(crate) fn check_grammar_await_or_await_using(&mut self, node: P<Node>) -> bool | grammarchecks.go:1658 | Checker
check_grammar_big_int_literal | pub(crate) fn check_grammar_big_int_literal(&mut self, node: P<Node>) -> bool | grammarchecks.go:2087 | Checker
check_grammar_binding_element | pub(crate) fn check_grammar_binding_element(&mut self, node: P<Node>) -> bool | grammarchecks.go:1518 | Checker
check_grammar_break_or_continue_statement | pub(crate) fn check_grammar_break_or_continue_statement(&mut self, node: P<Node>) -> bool | grammarchecks.go:1462 | Checker
check_grammar_class_declaration_heritage_clauses | pub(crate) fn check_grammar_class_declaration_heritage_clauses(&mut self, node: P<Node>, _file: P<SourceFile>) -> bool | grammarchecks.go:892 | Checker
check_grammar_class_like_declaration | pub(crate) fn check_grammar_class_like_declaration(&mut self, node: P<Node>) -> bool | grammarchecks.go:767 | Checker
check_grammar_computed_property_name | pub(crate) fn check_grammar_computed_property_name(&mut self, node: P<Node>) -> bool | grammarchecks.go:961 | Checker
check_grammar_constructor_type_annotation | pub(crate) fn check_grammar_constructor_type_annotation(&mut self, node: P<Node>) -> bool | grammarchecks.go:1856 | Checker
check_grammar_constructor_type_parameters | pub(crate) fn check_grammar_constructor_type_parameters(&mut self, node: P<Node>) -> bool | grammarchecks.go:1841 | Checker
check_grammar_decorator | pub(crate) fn check_grammar_decorator(&mut self, decorator: P<Node>) -> bool | grammarchecks.go:127 | Checker
check_grammar_export_declaration | pub(crate) fn check_grammar_export_declaration(&mut self, node: P<Node>) -> bool | grammarchecks.go:199 | Checker
check_grammar_expression_with_type_arguments | pub(crate) fn check_grammar_expression_with_type_arguments(&mut self, node: P<Node>) -> bool | grammarchecks.go:885 | Checker
check_grammar_for_at_least_one_type_argument | pub(crate) fn check_grammar_for_at_least_one_type_argument(&mut self, node: P<Node>, type_arguments: Option<P<NodeList>>) -> bool | grammarchecks.go:845 | Checker
check_grammar_for_disallowed_block_scoped_variable_statement | pub(crate) fn check_grammar_for_disallowed_block_scoped_variable_statement(&mut self, node: P<Node>) -> bool | grammarchecks.go:1772 | Checker
check_grammar_for_disallowed_trailing_comma | pub(crate) fn check_grammar_for_disallowed_trailing_comma(&mut self, list: Option<P<NodeList>>, diag: &'static Message) -> bool | grammarchecks.go:671 | Checker
check_grammar_for_es_module_marker_in_binding_name | pub(crate) fn check_grammar_for_es_module_marker_in_binding_name(&mut self, name: P<Node>) -> bool | grammarchecks.go:1596 | Checker
check_grammar_for_generator | pub(crate) fn check_grammar_for_generator(&mut self, node: P<Node>) -> bool | grammarchecks.go:974 | Checker
check_grammar_for_in_or_for_of_statement | pub(crate) fn check_grammar_for_in_or_for_of_statement(&mut self, for_in_or_of_statement: P<Node>) -> bool | grammarchecks.go:1182 | Checker
check_grammar_for_invalid_dynamic_name | pub(crate) fn check_grammar_for_invalid_dynamic_name(&mut self, node: P<Node>, message: &'static Message) -> bool | grammarchecks.go:1391 | Checker
check_grammar_for_invalid_exclamation_token | pub(crate) fn check_grammar_for_invalid_exclamation_token(&mut self, postfix_token: Option<P<Node>>, message: &'static Message) -> bool | grammarchecks.go:994 | Checker
check_grammar_for_invalid_question_mark | pub(crate) fn check_grammar_for_invalid_question_mark(&mut self, postfix_token: Option<P<Node>>, message: &'static Message) -> bool | grammarchecks.go:990 | Checker
check_grammar_for_use_strict_simple_parameter_list | pub(crate) fn check_grammar_for_use_strict_simple_parameter_list(&mut self, node: P<Node>) -> bool | grammarchecks.go:722 | Checker
check_grammar_function_like_declaration | pub(crate) fn check_grammar_function_like_declaration(&mut self, node: P<Node>) -> bool | grammarchecks.go:758 | Checker
check_grammar_heritage_clause | pub(crate) fn check_grammar_heritage_clause(&mut self, node: P<Node>) -> bool | grammarchecks.go:866 | Checker
check_grammar_import_attribute_values | pub(crate) fn check_grammar_import_attribute_values(&mut self, node: P<Node>) -> bool | grammarchecks.go:2123 | Checker
check_grammar_import_attributes_type | pub(crate) fn check_grammar_import_attributes_type(&mut self, attributes: P<Node>) -> bool | grammarchecks.go:2200 | Checker
check_grammar_import_call_expression | pub(crate) fn check_grammar_import_call_expression(&mut self, node: P<Node>) -> bool | grammarchecks.go:2157 | Checker
check_grammar_import_clause | pub(crate) fn check_grammar_import_clause(&mut self, node: P<Node>) -> bool | grammarchecks.go:2100 | Checker
check_grammar_index_signature | pub(crate) fn check_grammar_index_signature(&mut self, node: P<Node>) -> bool | grammarchecks.go:840 | Checker
check_grammar_index_signature_parameters | pub(crate) fn check_grammar_index_signature_parameters(&mut self, node: P<Node>) -> bool | grammarchecks.go:796 | Checker
check_grammar_interface_declaration | pub(crate) fn check_grammar_interface_declaration(&mut self, node: P<Node>) -> bool | grammarchecks.go:935 | Checker
check_grammar_jsx_element | pub(crate) fn check_grammar_jsx_element(&mut self, node: P<Node>) -> bool | grammarchecks.go:1138 | Checker
check_grammar_jsx_expression | pub(crate) fn check_grammar_jsx_expression(&mut self, node: P<Node>) -> bool | grammarchecks.go:1174 | Checker
check_grammar_jsx_name | pub(crate) fn check_grammar_jsx_name(&mut self, node: P<Node>) -> bool | grammarchecks.go:1162 | Checker
check_grammar_mapped_type | pub(crate) fn check_grammar_mapped_type(&mut self, node: P<Node>) -> bool | grammarchecks.go:120 | Checker
check_grammar_meta_property | pub(crate) fn check_grammar_meta_property(&mut self, node: P<Node>) -> bool | grammarchecks.go:1813 | Checker
check_grammar_method | pub(crate) fn check_grammar_method(&mut self, node: P<Node>) -> bool | grammarchecks.go:1414 | Checker
check_grammar_modifiers | pub(crate) fn check_grammar_modifiers(&mut self, node: P<Node>) -> bool | grammarchecks.go:214 | Checker
check_grammar_module_element_context | pub(crate) fn check_grammar_module_element_context(&mut self, node: P<Node>, error_message: &'static Message) -> bool | grammarchecks.go:206 | Checker
check_grammar_name_in_let_or_const_declarations | pub(crate) fn check_grammar_name_in_let_or_const_declarations(&mut self, name: P<Node>) -> bool | grammarchecks.go:1611 | Checker
check_grammar_numeric_literal | pub(crate) fn check_grammar_numeric_literal(&mut self, node: P<Node>) | grammarchecks.go:2059 | Checker
check_grammar_object_literal_expression | pub(crate) fn check_grammar_object_literal_expression(&mut self, node: P<Node>, in_destructuring: bool) -> bool | grammarchecks.go:998 | Checker
check_grammar_parameter_list | pub(crate) fn check_grammar_parameter_list(&mut self, parameters: P<NodeList>) -> bool | grammarchecks.go:687 | Checker
check_grammar_private_identifier_expression | pub(crate) fn check_grammar_private_identifier_expression(&mut self, priv_id: P<Node>) -> bool | grammarchecks.go:100 | Checker
check_grammar_property | pub(crate) fn check_grammar_property(&mut self, node: P<Node>) -> bool | grammarchecks.go:1864 | Checker
check_grammar_regular_expression_literal | pub(crate) fn check_grammar_regular_expression_literal(&mut self, node: P<Node>) -> bool | grammarchecks.go:69 | Checker
check_grammar_source_file | pub(crate) fn check_grammar_source_file(&mut self, node: P<SourceFile>) -> bool | grammarchecks.go:2025 | Checker
check_grammar_statement_in_ambient_context | pub(crate) fn check_grammar_statement_in_ambient_context(&mut self, node: P<Node>) -> bool | grammarchecks.go:2029 | Checker
check_grammar_tagged_template_chain | pub(crate) fn check_grammar_tagged_template_chain(&mut self, node: P<Node>) -> bool | grammarchecks.go:859 | Checker
check_grammar_top_level_element_for_required_declare_modifier | pub(crate) fn check_grammar_top_level_element_for_required_declare_modifier(&mut self, node: P<Node>) -> bool | grammarchecks.go:1994 | Checker
check_grammar_top_level_elements_for_required_declare_modifier | pub(crate) fn check_grammar_top_level_elements_for_required_declare_modifier(&mut self, file: P<SourceFile>) -> bool | grammarchecks.go:2014 | Checker
check_grammar_type_arguments | pub(crate) fn check_grammar_type_arguments(&mut self, node: P<Node>, type_arguments: Option<P<NodeList>>) -> bool | grammarchecks.go:855 | Checker
check_grammar_type_only_named_imports_or_exports | pub(crate) fn check_grammar_type_only_named_imports_or_exports(&mut self, named_bindings: P<Node>) -> bool | grammarchecks.go:2136 | Checker
check_grammar_type_operator_node | pub(crate) fn check_grammar_type_operator_node(&mut self, node: P<Node>) -> bool | grammarchecks.go:1351 | Checker
check_grammar_type_parameter_list | pub(crate) fn check_grammar_type_parameter_list(&mut self, type_parameters: Option<P<NodeList>>, file: P<SourceFile>) -> bool | grammarchecks.go:678 | Checker
check_grammar_variable_declaration | pub(crate) fn check_grammar_variable_declaration(&mut self, node: P<Node>) -> bool | grammarchecks.go:1539 | Checker
check_grammar_variable_declaration_list | pub(crate) fn check_grammar_variable_declaration_list(&mut self, declaration_list: P<Node>) -> bool | grammarchecks.go:1628 | Checker
check_grammar_yield_expression | pub(crate) fn check_grammar_yield_expression(&mut self, node: P<Node>) -> bool | grammarchecks.go:1759 | Checker
check_identifier | pub(crate) fn check_identifier(&mut self, node: P<Node>, check_mode: CheckMode) -> P<Type> | checker.go:11242 | Checker
check_if_expression_refines_any_parameter | pub(crate) fn check_if_expression_refines_any_parameter(&mut self, fn_: P<Node>, expr: P<Node>) -> Option<P<TypePredicate>> | checker.go:20906 | Checker
check_if_expression_refines_parameter | pub(crate) fn check_if_expression_refines_parameter(&mut self, fn_: P<Node>, expr: P<Node>, param: P<Node>, init_type: P<Type>) -> Option<P<Type>> | checker.go:20926 | Checker
check_if_statement | pub(crate) fn check_if_statement(&mut self, node: P<Node>) | checker.go:3830 | Checker
check_if_type_predicate_variable_is_declared_in_binding_pattern | pub(crate) fn check_if_type_predicate_variable_is_declared_in_binding_pattern(&mut self, pattern: P<Node>, predicate_variable_node: P<Node>, predicate_variable_name: &str) -> bool | checker.go:3159 | Checker
check_import_attributes | pub(crate) fn check_import_attributes(&mut self, declaration: P<Node>) | checker.go:5537 | Checker
check_import_attributes_expression | pub(crate) fn check_import_attributes_expression(&mut self, node: P<Node>) -> P<Type> | checker.go:5579 | Checker
check_import_attributes_type | pub(crate) fn check_import_attributes_type(&mut self, attributes: P<Node>) | checker.go:5320 | Checker
check_import_binding | pub(crate) fn check_import_binding(&mut self, node: P<Node>) | checker.go:5505 | Checker
check_import_call_expression | pub(crate) fn check_import_call_expression(&mut self, node: P<Node>) -> P<Type> | checker.go:8439 | Checker
check_import_declaration | pub(crate) fn check_import_declaration(&mut self, node: P<Node>) | checker.go:5398 | Checker
check_import_equals_declaration | pub(crate) fn check_import_equals_declaration(&mut self, node: P<Node>) | checker.go:5610 | Checker
check_import_meta_property | pub(crate) fn check_import_meta_property(&mut self, node: P<Node>) -> P<Type> | checker.go:10982 | Checker
check_import_type | pub(crate) fn check_import_type(&mut self, node: P<Node>) | checker.go:3372 | Checker
check_in_expression | pub(crate) fn check_in_expression(&mut self, left: P<Node>, right: P<Node>, left_type: P<Type>, right_type: P<Type>) -> P<Type> | checker.go:13285 | Checker
check_index_constraint_for_index_signature | pub(crate) fn check_index_constraint_for_index_signature(&mut self, t: P<Type>, check_info: P<IndexInfo>) | checker.go:4950 | Checker
check_index_constraint_for_property | pub(crate) fn check_index_constraint_for_property(&mut self, t: P<Type>, prop: P<Symbol>, prop_name_type: P<Type>, prop_type: P<Type>) | checker.go:4904 | Checker
check_index_constraints | pub(crate) fn check_index_constraints(&mut self, t: P<Type>, symbol: P<Symbol>, is_static_index: bool) | checker.go:4877 | Checker
check_indexed_access | pub(crate) fn check_indexed_access(&mut self, node: P<Node>, check_mode: CheckMode) -> P<Type> | checker.go:8305 | Checker
check_indexed_access_index_type | pub(crate) fn check_indexed_access_index_type(&mut self, t: P<Type>, access_node: P<Node>) -> P<Type> | checker.go:8392 | Checker
check_indexed_access_type | pub(crate) fn check_indexed_access_type(&mut self, node: P<Node>) | checker.go:3407 | Checker
check_infer_type | pub(crate) fn check_infer_type(&mut self, node: P<Node>) | checker.go:3336 | Checker
check_inherited_properties_are_identical | pub(crate) fn check_inherited_properties_are_identical(&mut self, t: P<Type>, type_node: Option<P<Node>>) -> bool | checker.go:5127 | Checker
check_instance_of_expression | pub(crate) fn check_instance_of_expression(&mut self, left: P<Node>, right: P<Node>, left_type: P<Type>, right_type: P<Type>, check_mode: CheckMode) -> P<Type> | checker.go:13255 | Checker
check_interface_declaration | pub(crate) fn check_interface_declaration(&mut self, node: P<Node>) | checker.go:5082 | Checker
check_iterated_type_or_element_type | pub(crate) fn check_iterated_type_or_element_type(&mut self, use_: IterationUse, input_type: P<Type>, sent_type: P<Type>, error_node: Option<P<Node>>) -> P<Type> | checker.go:6265 | Checker
check_jsdoc_augments_tag_matches_extends | pub(crate) fn check_jsdoc_augments_tag_matches_extends(&mut self, node: P<Node>, base_type_node: P<Node>, base_type: P<Type>) | checker.go:4424 | Checker
check_jsdoc_comment | pub(crate) fn check_jsdoc_comment(&mut self, node: P<Node>) | checker.go:2588 | Checker
check_jsdoc_comments | pub(crate) fn check_jsdoc_comments(&mut self, node: P<Node>) | checker.go:2582 | Checker
check_jsdoc_type | pub(crate) fn check_jsdoc_type(&mut self, node: P<Node>) | checker.go:2622 | Checker
check_jsdoc_type_is_in_js_file | pub(crate) fn check_jsdoc_type_is_in_js_file(&mut self, node: P<Node>) | checker.go:2627 | Checker
check_jsx_attribute | pub(crate) fn check_jsx_attribute(&mut self, node: P<Node>, check_mode: CheckMode) -> P<Type> | jsx.go:869 | Checker
check_jsx_attributes | pub(crate) fn check_jsx_attributes(&mut self, node: P<Node>, check_mode: CheckMode) -> P<Type> | jsx.go:126 | Checker
check_jsx_children | pub(crate) fn check_jsx_children(&mut self, node: P<Node>, check_mode: CheckMode) -> Vec<P<Type>> | jsx.go:877 | Checker
check_jsx_element | pub(crate) fn check_jsx_element(&mut self, node: P<Node>, _check_mode: CheckMode) -> P<Type> | jsx.go:72 | Checker
check_jsx_element_deferred | pub(crate) fn check_jsx_element_deferred(&mut self, node: P<Node>) | jsx.go:77 | Checker
check_jsx_expression | pub(crate) fn check_jsx_expression(&mut self, node: P<Node>, check_mode: CheckMode) -> P<Type> | jsx.go:89 | Checker
check_jsx_fragment | pub(crate) fn check_jsx_fragment(&mut self, node: P<Node>) -> P<Type> | jsx.go:110 | Checker
check_jsx_opening_like_element_or_opening_fragment | pub(crate) fn check_jsx_opening_like_element_or_opening_fragment(&mut self, node: P<Node>) | jsx.go:131 | Checker
check_jsx_preconditions | pub(crate) fn check_jsx_preconditions(&mut self, error_node: P<Node>) | jsx.go:160 | Checker
check_jsx_return_assignable_to_appropriate_bound | pub(crate) fn check_jsx_return_assignable_to_appropriate_bound(&mut self, ref_kind: JsxReferenceKind, elem_instance_type: P<Type>, opening_like_element: P<Node>) | jsx.go:170 | Checker
check_jsx_self_closing_element | pub(crate) fn check_jsx_self_closing_element(&mut self, node: P<Node>, _check_mode: CheckMode) -> P<Type> | jsx.go:101 | Checker
check_jsx_self_closing_element_deferred | pub(crate) fn check_jsx_self_closing_element_deferred(&mut self, node: P<Node>) | jsx.go:106 | Checker
check_kinds_of_property_member_overrides | pub(crate) fn check_kinds_of_property_member_overrides(&mut self, t: P<Type>, base_type: P<Type>) | checker.go:4588 | Checker
check_labeled_statement | pub(crate) fn check_labeled_statement(&mut self, node: P<Node>) | checker.go:4235 | Checker
check_mapped_type | pub(crate) fn check_mapped_type(&mut self, node: P<Node>) | checker.go:3412 | Checker
check_member_for_override_modifier | pub(crate) fn check_member_for_override_modifier(&mut self, node: P<Node>, static_type: P<Type>, base_static_type: P<Type>, base_with_this: Option<P<Type>>, t: P<Type>, type_with_this: P<Type>, member: P<Node>) | checker.go:4781 | Checker
check_member_for_override_modifier_worker | pub(crate) fn check_member_for_override_modifier_worker(&mut self, node: P<Node>, static_type: P<Type>, base_static_type: P<Type>, base_with_this: Option<P<Type>>, t: P<Type>, type_with_this: P<Type>, member_has_override_modifier: bool, member_has_abstract_modifier: bool, member_is_static: bool, member_is_parameter_property: bool, member: P<Symbol>, error_node: Option<P<Node>>) -> MemberOverrideStatus | checker.go:4815 | Checker
check_members_for_override_modifier | pub(crate) fn check_members_for_override_modifier(&mut self, node: P<Node>, t: P<Type>, type_with_this: P<Type>, static_type: P<Type>) | checker.go:4756 | Checker
check_meta_property | pub(crate) fn check_meta_property(&mut self, node: P<Node>) -> P<Type> | checker.go:10953 | Checker
check_meta_property_keyword | pub(crate) fn check_meta_property_keyword(&self, node: P<Node>) -> P<Type> | checker.go:10999 | Checker
check_method_declaration | pub(crate) fn check_method_declaration(&mut self, node: P<Node>) | checker.go:2840 | Checker
check_missing_declaration | pub(crate) fn check_missing_declaration(&mut self, node: P<Node>) | checker.go:5925 | Checker
check_module_augmentation_element | pub(crate) fn check_module_augmentation_element(&mut self, node: P<Node>) | checker.go:5370 | Checker
check_module_declaration | pub(crate) fn check_module_declaration(&mut self, node: P<Node>) | checker.go:5223 | Checker
check_module_export_name | pub(crate) fn check_module_export_name(&mut self, name: Option<P<Node>>, allow_string_literal: bool) | checker.go:5517 | Checker
check_named_tuple_member | pub(crate) fn check_named_tuple_member(&mut self, node: P<Node>) | checker.go:3392 | Checker
check_nan_equality | pub(crate) fn check_nan_equality(&mut self, error_node: Option<P<Node>>, operator: Kind, left: P<Node>, right: P<Node>) | checker.go:13035 | Checker
check_new_target_meta_property | pub(crate) fn check_new_target_meta_property(&mut self, node: P<Node>) -> P<Type> | checker.go:10968 | Checker
check_no_type_arguments | pub(crate) fn check_no_type_arguments(&mut self, node: P<Node>, symbol: Option<P<Symbol>>) -> bool | checker.go:23681 | Checker
check_node_deferred | pub(crate) fn check_node_deferred(&mut self, node: P<Node>) | checker.go:2525 | Checker
check_non_null_assertion | pub(crate) fn check_non_null_assertion(&mut self, node: P<Node>) -> P<Type> | checker.go:10819 | Checker
check_non_null_chain | pub(crate) fn check_non_null_chain(&mut self, node: P<Node>) -> P<Type> | checker.go:10828 | Checker
check_non_null_expression | pub(crate) fn check_non_null_expression(&mut self, node: P<Node>) -> P<Type> | checker.go:7577 | Checker
check_non_null_non_void_type | pub(crate) fn check_non_null_non_void_type(&mut self, t: P<Type>, node: P<Node>) -> P<Type> | checker.go:7609 | Checker
check_non_null_type | pub(crate) fn check_non_null_type(&mut self, t: P<Type>, node: P<Node>) -> P<Type> | checker.go:7581 | Checker
check_non_null_type_with_reporter | pub(crate) fn check_non_null_type_with_reporter(&mut self, t: P<Type>, node: P<Node>, report_error: impl FnMut(&mut Checker, P<Node>, TypeFacts)) -> P<Type> | checker.go:7585 | Checker
check_not_canceled | pub(crate) fn check_not_canceled(&self) | utilities.go:1716 | Checker
check_nullish_coalesce_operand_left | pub(crate) fn check_nullish_coalesce_operand_left(&mut self, left: P<Node>) | checker.go:13144 | Checker
check_nullish_coalesce_operands | pub(crate) fn check_nullish_coalesce_operands(&mut self, left: P<Node>, right: P<Node>) | checker.go:13123 | Checker
check_object_literal | pub(crate) fn check_object_literal(&mut self, node: P<Node>, check_mode: CheckMode) -> P<Type> | checker.go:13352 | Checker
check_object_literal_assignment | pub(crate) fn check_object_literal_assignment(&mut self, node: P<Node>, source_type: P<Type>, right_is_this: bool) -> P<Type> | checker.go:12788 | Checker
check_object_literal_destructuring_property_assignment | pub(crate) fn check_object_literal_destructuring_property_assignment(&mut self, node: P<Node>, object_literal_type: P<Type>, property_index: usize, all_properties: Option<P<NodeList>>, right_is_this: bool) -> Option<P<Type>> | checker.go:12800 | Checker
check_object_literal_method | pub(crate) fn check_object_literal_method(&mut self, node: P<Node>, check_mode: CheckMode) -> P<Type> | checker.go:14100 | Checker
check_object_type_for_duplicate_declarations | pub(crate) fn check_object_type_for_duplicate_declarations(&mut self, node: P<Node>, check_private_names: bool) | checker.go:3190 | Checker
check_parameter | pub(crate) fn check_parameter(&mut self, node: P<Node>) | checker.go:2697 | Checker
check_parenthesized_expression | pub(crate) fn check_parenthesized_expression(&mut self, node: P<Node>, check_mode: CheckMode) -> P<Type> | checker.go:10235 | Checker
check_postfix_unary_expression | pub(crate) fn check_postfix_unary_expression(&mut self, node: P<Node>) -> P<Type> | checker.go:11109 | Checker
check_prefix_unary_expression | pub(crate) fn check_prefix_unary_expression(&mut self, node: P<Node>) -> P<Type> | checker.go:11055 | Checker
check_private_identifier_expression | pub(crate) fn check_private_identifier_expression(&mut self, node: P<Node>) -> P<Type> | checker.go:8009 | Checker
check_private_identifier_property_access | pub(crate) fn check_private_identifier_property_access(&mut self, left_type: P<Type>, right: P<Node>, lexically_scoped_identifier: Option<P<Symbol>>) -> bool | checker.go:11695 | Checker
check_property_access_chain | pub(crate) fn check_property_access_chain(&mut self, node: P<Node>, check_mode: CheckMode) -> P<Type> | checker.go:11452 | Checker
check_property_access_expression | pub(crate) fn check_property_access_expression(&mut self, node: P<Node>, check_mode: CheckMode, write_only: bool) -> P<Type> | checker.go:11444 | Checker
check_property_access_expression_or_qualified_name | pub(crate) fn check_property_access_expression_or_qualified_name(&mut self, node: P<Node>, left: P<Node>, left_type: P<Type>, right: P<Node>, check_mode: CheckMode, write_only: bool) -> P<Type> | checker.go:11458 | Checker
check_property_accessibility | pub(crate) fn check_property_accessibility(&mut self, node: P<Node>, is_super: bool, writing: bool, t: P<Type>, prop: P<Symbol>) -> bool | checker.go:11955 | Checker
check_property_accessibility_at_location | pub(crate) fn check_property_accessibility_at_location(&mut self, location: P<Node>, is_super: bool, writing: bool, containing_type: P<Type>, prop: P<Symbol>, error_node: Option<P<Node>>) -> bool | checker.go:11988 | Checker
check_property_accessibility_ex | pub(crate) fn check_property_accessibility_ex(&mut self, node: P<Node>, is_super: bool, writing: bool, t: P<Type>, prop: P<Symbol>, report_error: bool) -> bool | checker.go:11959 | Checker
check_property_assignment | pub(crate) fn check_property_assignment(&mut self, node: P<Node>, check_mode: CheckMode) -> P<Type> | checker.go:13908 | Checker
check_property_declaration | pub(crate) fn check_property_declaration(&mut self, node: P<Node>) | checker.go:2744 | Checker
check_property_initialization | pub(crate) fn check_property_initialization(&mut self, node: P<Node>) | checker.go:5024 | Checker
check_property_not_used_before_declaration | pub(crate) fn check_property_not_used_before_declaration(&mut self, prop: P<Symbol>, node: P<Node>, right: P<Node>) | checker.go:11911 | Checker
check_property_signature | pub(crate) fn check_property_signature(&mut self, node: P<Node>) | checker.go:2759 | Checker
check_qualified_name | pub(crate) fn check_qualified_name(&mut self, node: P<Node>, check_mode: CheckMode) -> P<Type> | checker.go:8294 | Checker
check_reference_assignment | pub(crate) fn check_reference_assignment(&mut self, target: P<Node>, source_type: P<Type>, check_mode: CheckMode) -> P<Type> | checker.go:12912 | Checker
check_reference_expression | pub(crate) fn check_reference_expression(&mut self, expr: P<Node>, invalid_reference_message: &'static Message, invalid_optional_chain_message: &'static Message) -> bool | checker.go:13338 | Checker
check_reflect_collision | pub(crate) fn check_reflect_collision(&mut self, node: P<Node>) | checker.go:10779 | Checker
check_regular_expression_literal | pub(crate) fn check_regular_expression_literal(&mut self, node: P<Node>) -> P<Type> | checker.go:8184 | Checker
check_resolved_block_scoped_variable | pub(crate) fn check_resolved_block_scoped_variable(&mut self, result: P<Symbol>, error_location: P<Node>) | checker.go:1929 | Checker
check_return_expression | pub(crate) fn check_return_expression(&mut self, container: P<Node>, unwrapped_return_type: P<Type>, node: P<Node>, expr: Option<P<Node>>, expr_type: P<Type>, in_conditional_expression: bool) | checker.go:4159 | Checker
check_return_statement | pub(crate) fn check_return_statement(&mut self, node: P<Node>) | checker.go:4114 | Checker
check_right_hand_side_of_for_of | pub(crate) fn check_right_hand_side_of_for_of(&mut self, statement: P<Node>) -> P<Type> | checker.go:18018 | Checker
check_satisfies_expression | pub(crate) fn check_satisfies_expression(&mut self, node: P<Node>) -> P<Type> | checker.go:10941 | Checker
check_shorthand_property_assignment | pub(crate) fn check_shorthand_property_assignment(&mut self, node: P<Node>, in_destructuring_pattern: bool, check_mode: CheckMode) -> P<Type> | checker.go:13924 | Checker
check_signature_declaration | pub(crate) fn check_signature_declaration(&mut self, node: P<Node>) | checker.go:2766 | Checker
check_source_element | pub(crate) fn check_source_element(&mut self, node: Option<P<Node>>) -> bool | checker.go:2282 | Checker
check_source_element_unreachable | pub(crate) fn check_source_element_unreachable(&mut self, node: P<Node>) -> bool | checker.go:2433 | Checker
check_source_element_worker | pub(crate) fn check_source_element_worker(&mut self, node: P<Node>) | checker.go:2295 | Checker
check_source_elements | pub(crate) fn check_source_elements(&mut self, nodes: &[P<Node>]) | checker.go:2273 | Checker
check_source_file | pub(crate) fn check_source_file(&mut self, ctx: &Context, source_file: P<SourceFile>, check_unused: bool) | checker.go:2237 | Checker
check_source_file_piece | pub fn check_source_file_piece(&mut self, ctx: &Context, source_file: P<SourceFile>, statements: std::ops::Range<usize>) -> (Vec<P<Diagnostic>>, Vec<P<Diagnostic>>) | rust:checker_02.rs:147 | Checker
check_source_file_worker | fn check_source_file_worker(&mut self, ctx: &Context, source_file: P<SourceFile>, check_unused: bool) | rust:checker_02.rs:101 | Checker
check_spread_expression | pub(crate) fn check_spread_expression(&mut self, node: P<Node>, check_mode: CheckMode) -> P<Type> | checker.go:11147 | Checker
check_spread_prop_overrides | pub(crate) fn check_spread_prop_overrides(&mut self, t: P<Type>, props: Option<&SymbolTable>, spread: P<Node>) | checker.go:13589 | Checker
check_super_expression | pub(crate) fn check_super_expression(&mut self, node: P<Node>) -> P<Type> | checker.go:8026 | Checker
check_switch_statement | pub(crate) fn check_switch_statement(&mut self, node: P<Node>) | checker.go:4199 | Checker
check_synthetic_expression | pub(crate) fn check_synthetic_expression(&mut self, node: P<Node>) -> P<Type> | checker.go:11234 | Checker
check_tag_name_does_not_expect_too_many_arguments | fn check_tag_name_does_not_expect_too_many_arguments(c: &mut Checker, node: P<Node>, report_errors: bool, diagnostic_output: Option<&mut Vec<P<Diagnostic>>>) -> bool | rust:jsx.rs:1668 | -
check_tagged_template_expression | pub(crate) fn check_tagged_template_expression(&mut self, node: P<Node>) -> P<Type> | checker.go:10226 | Checker
check_template_expression | pub(crate) fn check_template_expression(&mut self, node: P<Node>) -> P<Type> | checker.go:8148 | Checker
check_template_literal_type | pub(crate) fn check_template_literal_type(&mut self, node: P<Node>) | checker.go:3363 | Checker
check_testing_known_truthy_callable_or_awaitable_or_enum_member_type | pub(crate) fn check_testing_known_truthy_callable_or_awaitable_or_enum_member_type(&mut self, cond_expr: P<Node>, cond_type: P<Type>, body: Option<P<Node>>) | checker.go:3842 | Checker
check_testing_known_truthy_type | pub(crate) fn check_testing_known_truthy_type(&mut self, cond_expr: P<Node>, cond_type: P<Type>, body: Option<P<Node>>) | checker.go:3858 | Checker
check_testing_known_truthy_types | pub(crate) fn check_testing_known_truthy_types(&mut self, cond_expr: P<Node>, cond_type: P<Type>, body: Option<P<Node>>) | checker.go:3849 | Checker
check_this_before_super | pub(crate) fn check_this_before_super(&mut self, node: P<Node>, container: P<Node>, diagnostic_message: &'static Message) | checker.go:12466 | Checker
check_this_expression | pub(crate) fn check_this_expression(&mut self, node: P<Node>) -> P<Type> | checker.go:12280 | Checker
check_this_in_static_class_field_initializer_in_decorated_class | pub(crate) fn check_this_in_static_class_field_initializer_in_decorated_class(&mut self, this_expression: P<Node>, container: P<Node>) | checker.go:12457 | Checker
check_this_type | pub(crate) fn check_this_type(&mut self, node: P<Node>) | checker.go:3323 | Checker
check_throw_statement | pub(crate) fn check_throw_statement(&mut self, node: P<Node>) | checker.go:4253 | Checker
check_truncation_length | pub(crate) fn check_truncation_length(&self, _c: &mut Checker) -> bool | nodebuilderimpl.go:146 | NodeBuilderImpl
check_truncation_length_if_expanding | pub(crate) fn check_truncation_length_if_expanding(&self, c: &mut Checker) -> bool | nodebuilderimpl.go:164 | NodeBuilderImpl
check_truthiness_expression | pub(crate) fn check_truthiness_expression(&mut self, node: P<Node>, check_mode: CheckMode) -> P<Type> | checker.go:11143 | Checker
check_truthiness_of_type | pub(crate) fn check_truthiness_of_type(&mut self, t: P<Type>, node: P<Node>) -> P<Type> | checker.go:13073 | Checker
check_try_statement | pub(crate) fn check_try_statement(&mut self, node: P<Node>) | checker.go:4263 | Checker
check_tuple_type | pub(crate) fn check_tuple_type(&mut self, node: P<Node>) | checker.go:3281 | Checker
check_type | pub fn check_type(&self) -> Option<P<Type>> | rust:types.rs:2904 | ConditionalType
check_type_alias_declaration | pub(crate) fn check_type_alias_declaration(&mut self, node: P<Node>) | checker.go:7048 | Checker
check_type_argument_constraints | pub(crate) fn check_type_argument_constraints(&mut self, node: P<Node>, type_parameters: &[P<Type>]) -> bool | checker.go:3064 | Checker
check_type_arguments | pub(crate) fn check_type_arguments(&mut self, signature: P<Signature>, type_argument_nodes: &[P<Node>], report_errors: bool, head_message: Option<&'static Message>) -> Vec<P<Type>> | checker.go:9414 | Checker
check_type_assignable_to | pub(crate) fn check_type_assignable_to(&mut self, source: P<Type>, target: P<Type>, error_node: Option<P<Node>>, head_message: Option<&'static Message>) -> bool | relater.go:339 | Checker
check_type_assignable_to_and_optionally_elaborate | pub(crate) fn check_type_assignable_to_and_optionally_elaborate(&mut self, source: P<Type>, target: P<Type>, error_node: Option<P<Node>>, expr: Option<P<Node>>, head_message: Option<&'static Message>, diagnostic_output: Option<&mut Vec<P<Diagnostic>>>) -> bool | relater.go:424 | Checker
check_type_assignable_to_ex | pub(crate) fn check_type_assignable_to_ex(&mut self, source: P<Type>, target: P<Type>, error_node: Option<P<Node>>, head_message: Option<&'static Message>, diagnostic_output: &mut Vec<P<Diagnostic>>) -> bool | relater.go:343 | Checker
check_type_comparable_to | pub(crate) fn check_type_comparable_to(&mut self, source: P<Type>, target: P<Type>, error_node: P<Node>, head_message: Option<&'static Message>) -> bool | relater.go:347 | Checker
check_type_expandability | pub(crate) fn check_type_expandability(&self, c: &mut Checker, t: Option<P<Type>>) | nodebuilderimpl.go:239 | NodeBuilderImpl
check_type_expandability_worker | fn check_type_expandability_worker(&self, c: &mut Checker, t: P<Type>) | rust:nodebuilderimpl_1.rs:191 | NodeBuilderImpl
check_type_for_duplicate_index_signatures | pub(crate) fn check_type_for_duplicate_index_signatures(&mut self, node: P<Node>) | checker.go:4995 | Checker
check_type_literal | pub(crate) fn check_type_literal(&mut self, node: P<Node>) | checker.go:3182 | Checker
check_type_name_is_reserved | pub(crate) fn check_type_name_is_reserved(&mut self, name: P<Node>, message: &'static Message) | checker.go:7073 | Checker
check_type_of_expression | pub(crate) fn check_type_of_expression(&mut self, node: P<Node>) -> P<Type> | checker.go:10814 | Checker
check_type_operator | pub(crate) fn check_type_operator(&mut self, node: P<Node>) | checker.go:3327 | Checker
check_type_parameter | pub(crate) fn check_type_parameter(&mut self, node: P<Node>) | checker.go:2646 | Checker
check_type_parameter_deferred | pub(crate) fn check_type_parameter_deferred(&mut self, node: P<Node>) | checker.go:2670 | Checker
check_type_parameter_lists_identical | pub(crate) fn check_type_parameter_lists_identical(&mut self, symbol: P<Symbol>) | checker.go:4473 | Checker
check_type_parameters | pub(crate) fn check_type_parameters(&mut self, type_parameter_declarations: &[P<Node>]) | checker.go:7174 | Checker
check_type_parameters_not_referenced | pub(crate) fn check_type_parameters_not_referenced(&mut self, root: P<Node>, type_parameters: &[P<Node>], index: usize) | checker.go:7194 | Checker
check_type_predicate | pub(crate) fn check_type_predicate(&mut self, node: P<Node>) | checker.go:3103 | Checker
check_type_query | pub(crate) fn check_type_query(&mut self, node: P<Node>) | checker.go:3178 | Checker
check_type_reference_node | pub(crate) fn check_type_reference_node(&mut self, node: P<Node>) | checker.go:3028 | Checker
check_type_reference_or_import | pub(crate) fn check_type_reference_or_import(&mut self, node: P<Node>) | checker.go:3046 | Checker
check_type_related_to | pub(crate) fn check_type_related_to(&mut self, source: P<Type>, target: P<Type>, relation: P<Relation>, error_node: Option<P<Node>>) -> bool | relater.go:351 | Checker
check_type_related_to_and_optionally_elaborate | pub(crate) fn check_type_related_to_and_optionally_elaborate(&mut self, source: P<Type>, target: P<Type>, relation: P<Relation>, error_node: Option<P<Node>>, expr: Option<P<Node>>, head_message: Option<&'static Message>, diagnostic_output: Option<&mut Vec<P<Diagnostic>>>) -> bool | relater.go:428 | Checker
check_type_related_to_ex | pub(crate) fn check_type_related_to_ex(&mut self, source: P<Type>, target: P<Type>, relation: P<Relation>, error_node: Option<P<Node>>, head_message: Option<&'static Message>, diagnostic_output: Option<&mut Vec<P<Diagnostic>>>) -> bool | relater.go:358 | Checker
check_union_or_intersection_type | pub(crate) fn check_union_or_intersection_type(&mut self, node: P<Node>) | checker.go:3318 | Checker
check_unmatched_jsdoc_parameters | pub(crate) fn check_unmatched_jsdoc_parameters(&mut self, node: P<Node>) | jsdoc.go:9 | Checker
check_unused_class_members | pub(crate) fn check_unused_class_members(&mut self, node: P<Node>) | checker.go:7287 | Checker
check_unused_identifiers | pub(crate) fn check_unused_identifiers(&mut self, potentially_unused_identifiers: &[P<Node>]) | checker.go:7218 | Checker
check_unused_infer_type_parameter | pub(crate) fn check_unused_infer_type_parameter(&mut self, node: P<Node>) | checker.go:7454 | Checker
check_unused_locals_and_parameters | pub(crate) fn check_unused_locals_and_parameters(&mut self, node: P<Node>) | checker.go:7312 | Checker
check_unused_renamed_binding_elements | pub(crate) fn check_unused_renamed_binding_elements(&mut self) | checker.go:7486 | Checker
check_unused_type_parameters | pub(crate) fn check_unused_type_parameters(&mut self, node: P<Node>) | checker.go:7461 | Checker
check_var_declared_names_not_shadowed | pub(crate) fn check_var_declared_names_not_shadowed(&mut self, node: P<Node>) | checker.go:6131 | Checker
check_variable_declaration | pub(crate) fn check_variable_declaration(&mut self, node: P<Node>) | checker.go:5946 | Checker
check_variable_declaration_list | pub(crate) fn check_variable_declaration_list(&mut self, node: P<Node>) | checker.go:5938 | Checker
check_variable_like_declaration | pub(crate) fn check_variable_like_declaration(&mut self, node: P<Node>) | checker.go:5955 | Checker
check_variable_statement | pub(crate) fn check_variable_statement(&mut self, node: P<Node>) | checker.go:5929 | Checker
check_void_expression | pub(crate) fn check_void_expression(&mut self, node: P<Node>) -> P<Type> | checker.go:11040 | Checker
check_weak_map_set_collision | pub(crate) fn check_weak_map_set_collision(&mut self, node: P<Node>) | checker.go:10745 | Checker
check_while_statement | pub(crate) fn check_while_statement(&mut self, node: P<Node>) | checker.go:3981 | Checker
check_with_statement | pub(crate) fn check_with_statement(&mut self, node: P<Node>) | checker.go:4184 | Checker
check_yield_expression | pub(crate) fn check_yield_expression(&mut self, node: P<Node>) -> P<Type> | checker.go:11152 | Checker
checking_file | fn checking_file(c: &Checker) -> String | rust:uniontrace.rs:96 | -
choose_overload | pub(crate) fn choose_overload(&mut self, s: &mut CallState, relation: P<Relation>) -> Option<P<Signature>> | checker.go:9213 | Checker
choose_overload_candidate | fn choose_overload_candidate(&mut self, s: &mut CallState, relation: P<Relation>, node: P<Node>, args: &[P<Node>], type_arguments: &[P<Node>], candidate_index: usize, inference_context: &mut Option<P<InferenceContext>>) -> Option<P<Signature>> | rust:checker_05.rs:597 | Checker
class_declaration_extends_null | pub(crate) fn class_declaration_extends_null(&mut self, class_decl: P<Node>) -> bool | checker.go:12483 | Checker
classify_property_name | pub(crate) fn classify_property_name(name: &str, string_named: bool, is_method: bool) -> propertyNameNodeKind | nodebuilderimpl.go:2456 | -
clear | pub fn clear(&self) | rust:types.rs:134 | GoMap
clear | pub fn clear(&self) | rust:checker.rs:578 | LazyVec
clear | pub fn clear(&mut self) | rust:packedmap.rs:110 | PackedMap
clear | pub(crate) fn clear(&self) | rust:relater_1.rs:75 | Relation
clear_active_mapper_caches | pub(crate) fn clear_active_mapper_caches(&mut self) | checker.go:22600 | Checker
clear_cached_inferences | pub(crate) fn clear_cached_inferences(inferences: &[P<InferenceInfo>]) | inference.go:1643 | -
clear_intra_expression_inference_sites | pub fn clear_intra_expression_inference_sites(&self) | rust:checker.rs:472 | InferenceContext
clear_relation_caches | pub fn clear_relation_caches(&self) | rust:checker.rs:3107 | Checker
clear_scratch | pub fn clear_scratch(&self) | rust:types.rs:143 | GoMap
clone_binding_name | pub(crate) fn clone_binding_name(&self, c: &mut Checker, node: P<Node>) -> P<Node> | nodebuilderimpl.go:1785 | NodeBuilderImpl
clone_inference_context | pub(crate) fn clone_inference_context(n: Option<P<InferenceContext>>, extra_flags: InferenceFlags) -> Option<P<InferenceContext>> | inference.go:1258 | Checker
clone_inference_info | pub(crate) fn clone_inference_info(info: P<InferenceInfo>) -> P<InferenceInfo> | inference.go:1630 | -
clone_inferred_part_of_context | pub(crate) fn clone_inferred_part_of_context(n: P<InferenceContext>) -> Option<P<InferenceContext>> | inference.go:1265 | Checker
clone_node_builder_context | pub(crate) fn clone_node_builder_context(context: P<NodeBuilderContext>) -> Box<dyn FnMut()> | nodebuilderscopes.go:10 | -
clone_signature | pub(crate) fn clone_signature(&mut self, sig: P<Signature>) -> P<Signature> | checker.go:19651 | Checker
clone_symbol | pub(crate) fn clone_symbol(&mut self, symbol: P<Symbol>) -> P<Symbol> | checker.go:14572 | Checker
clone_type_as_module_type | pub(crate) fn clone_type_as_module_type(&mut self, symbol: P<Symbol>, module_type: P<Type>, reference_parent: P<Node>) -> P<Symbol> | checker.go:16044 | Checker
clone_type_parameter | pub(crate) fn clone_type_parameter(&mut self, tp: P<Type>) -> P<Type> | checker.go:22943 | Checker
clone_type_reference | pub(crate) fn clone_type_reference(&mut self, source: P<Type>) -> P<Type> | checker.go:25607 | Checker
collect_intersection_recursion_keys | fn collect_intersection_recursion_keys(c: &mut Checker, target: P<Type>, keys: &mut Vec<u64>) | rust:relater_1.rs:1275 | -
combine_iteration_types | pub(crate) fn combine_iteration_types(&mut self, iteration_types: &[IterationTypes]) -> IterationTypes | checker.go:6590 | Checker
combine_symbol_tables | pub(crate) fn combine_symbol_tables(&mut self, first: Option<P<SymbolTable>>, second: Option<P<SymbolTable>>) -> Option<P<SymbolTable>> | checker.go:14331 | Checker
combine_type_mappers | pub(crate) fn combine_type_mappers(m1: Option<P<TypeMapper>>, m2: P<TypeMapper>) -> P<TypeMapper> | rust:mapper.rs:435 | Checker
combine_union_or_intersection_member_signatures | pub(crate) fn combine_union_or_intersection_member_signatures(&mut self, left: P<Signature>, right: P<Signature>, is_union: bool) -> P<Signature> | checker.go:21524 | Checker
combine_union_or_intersection_parameters | pub(crate) fn combine_union_or_intersection_parameters(&mut self, left: P<Signature>, right: P<Signature>, mapper: Option<P<TypeMapper>>, is_union: bool) -> Vec<P<Symbol>> | checker.go:21563 | Checker
combine_union_or_intersection_this_param | pub(crate) fn combine_union_or_intersection_this_param(&mut self, left: Option<P<Symbol>>, right: Option<P<Symbol>>, mapper: Option<P<TypeMapper>>, is_union: bool) -> Option<P<Symbol>> | checker.go:21629 | Checker
combine_value_and_type_symbols | pub(crate) fn combine_value_and_type_symbols(&mut self, value_symbol: P<Symbol>, type_symbol: P<Symbol>) -> P<Symbol> | checker.go:15009 | Checker
compare_element_labels | pub(crate) fn compare_element_labels(n1: Option<P<Node>>, n2: Option<P<Node>>) -> Ordering | utilities.go:691 | -
compare_names | fn compare_names(a: &str, b: &str) -> Ordering | rust:utilities.rs:994 | -
compare_nodes | pub(crate) fn compare_nodes(&mut self, n1: Option<P<Node>>, n2: Option<P<Node>>) -> Ordering | utilities.go:392 | Checker
compare_numbers | fn compare_numbers(a: jsnum::Number, b: jsnum::Number) -> Ordering | rust:utilities.rs:566 | -
compare_properties | pub(crate) fn compare_properties(&mut self, source_prop: P<Symbol>, target_prop: P<Symbol>, compare_types: impl FnMut(&mut Checker, P<Type>, P<Type>) -> Ternary) -> Ternary | checker.go:28142 | Checker
compare_signatures_identical | pub(crate) fn compare_signatures_identical(&mut self, source: P<Signature>, target: P<Signature>, partial_match: bool, ignore_this_types: bool, ignore_return_types: bool, compare_types: impl FnMut(&mut Checker, P<Type>, P<Type>) -> Ternary) -> Ternary | relater.go:2200 | Checker
compare_signatures_related | pub(crate) fn compare_signatures_related(&mut self, source: P<Signature>, target: P<Signature>, check_mode: SignatureCheckMode, report_errors: bool, error_reporter: Option<ErrorReporter<'_>>, compare_types: TypeComparer, report_unreliable_markers: Option<P<TypeMapper>>) -> Ternary | relater.go:1491 | Checker
compare_string_literal_types | fn compare_string_literal_types(t1: P<Type>, t2: P<Type>) -> Ordering | rust:utilities.rs:616 | -
compare_symbol_chains | pub(crate) fn compare_symbol_chains(&mut self, a: &[P<Symbol>], b: &[P<Symbol>]) -> std::cmp::Ordering | rust:checker.rs:2392 | Checker
compare_symbol_chains_worker | pub(crate) fn compare_symbol_chains_worker(&mut self, a: &[P<Symbol>], b: &[P<Symbol>]) -> std::cmp::Ordering | symbolaccessibility.go:595 | Checker
compare_symbols | pub(crate) fn compare_symbols(&mut self, s1: Option<P<Symbol>>, s2: Option<P<Symbol>>) -> std::cmp::Ordering | rust:checker.rs:2384 | Checker
compare_symbols_exported | pub fn compare_symbols_exported(&mut self, s1: Option<P<Symbol>>, s2: Option<P<Symbol>>) -> std::cmp::Ordering | exports.go:394 | Checker
compare_symbols_worker | pub(crate) fn compare_symbols_worker(&mut self, s1: Option<P<Symbol>>, s2: Option<P<Symbol>>) -> Ordering | utilities.go:365 | Checker
compare_tuple_types | pub(crate) fn compare_tuple_types(t1: &'static TupleType, t2: &'static TupleType) -> Ordering | utilities.go:668 | -
compare_type_lists | pub(crate) fn compare_type_lists(c: &mut Checker, s1: &[P<Type>], s2: &[P<Type>]) -> Ordering | utilities.go:704 | -
compare_type_mappers | pub(crate) fn compare_type_mappers(c: &mut Checker, m1: Option<P<TypeMapper>>, m2: Option<P<TypeMapper>>) -> Ordering | utilities.go:716 | -
compare_type_names | pub(crate) fn compare_type_names(c: &mut Checker, t1: P<Type>, t2: P<Type>) -> Ordering | utilities.go:632 | -
compare_type_parameters_identical | pub(crate) fn compare_type_parameters_identical(&mut self, source_params: &[P<Type>], target_params: &[P<Type>]) -> bool | relater.go:2280 | Checker
compare_type_predicate_related_to | pub(crate) fn compare_type_predicate_related_to(&mut self, source: P<TypePredicate>, target: P<TypePredicate>, report_errors: bool, error_reporter: Option<ErrorReporter<'_>>, compare_types: TypeComparer) -> Ternary | relater.go:1675 | Checker
compare_type_predicates_identical | pub(crate) fn compare_type_predicates_identical(&mut self, source: Option<P<TypePredicate>>, target: Option<P<TypePredicate>>, compare_types: impl FnMut(&mut Checker, P<Type>, P<Type>) -> Ternary) -> Ternary | relater.go:2303 | Checker
compare_types | pub fn compare_types(c: &mut Checker, t1: Option<P<Type>>, t2: Option<P<Type>>) -> Ordering | utilities.go:414 | -
compare_types_and_depth | pub(crate) fn compare_types_and_depth(c: &mut Checker, t1: P<Type>, t2: P<Type>) -> std::cmp::Ordering | inference.go:410 | -
compare_types_assignable | pub(crate) fn compare_types_assignable(&mut self, source: P<Type>, target: P<Type>, report_errors: bool) -> Ternary | rust:checker.rs:2460 | Checker
compare_types_assignable_comparer | pub(crate) fn compare_types_assignable_comparer() -> TypeComparer | rust:checker.rs:2465 | Checker
compare_types_assignable_simple | pub(crate) fn compare_types_assignable_simple(&mut self, source: P<Type>, target: P<Type>) -> Ternary | relater.go:128 | Checker
compare_types_assignable_worker | pub(crate) fn compare_types_assignable_worker(&mut self, source: P<Type>, target: P<Type>, report_errors: bool) -> Ternary | relater.go:135 | Checker
compare_types_equal | pub(crate) fn compare_types_equal(s: P<Type>, t: P<Type>) -> Ternary | checker.go:28169 | -
compare_types_identical | pub(crate) fn compare_types_identical(&mut self, source: P<Type>, target: P<Type>) -> Ternary | relater.go:121 | Checker
compare_types_same_flags | fn compare_types_same_flags(c: &mut Checker, t1: P<Type>, t2: P<Type>) -> Ordering | rust:utilities.rs:621 | -
compare_types_subtype_of | pub(crate) fn compare_types_subtype_of(&mut self, source: P<Type>, target: P<Type>) -> Ternary | relater.go:142 | Checker
composite | pub fn composite(&self) -> Option<P<CompositeSignature>> | rust:types.rs:3075 | Signature
composite_mapper_m2 | fn composite_mapper_m2(m: P<TypeMapper>) -> P<TypeMapper> | rust:utilities.rs:925 | -
compute_base_constraint | pub(crate) fn compute_base_constraint(&mut self, t: P<Type>, stack: BaseConstraintStack<'_>) -> Option<P<Type>> | checker.go:27960 | Checker
compute_constant_enum_member_value | pub(crate) fn compute_constant_enum_member_value(&mut self, member: P<Node>) -> evaluator::Result | checker.go:24465 | Checker
compute_enum_member_value | pub(crate) fn compute_enum_member_value(&mut self, member: P<Node>, auto_value: Option<&mut Number>, previous: Option<P<Node>>) -> evaluator::Result | checker.go:24428 | Checker
compute_enum_member_values | pub(crate) fn compute_enum_member_values(&mut self, node: P<Node>) | checker.go:24408 | Checker
compute_exhaustive_switch_statement | pub(crate) fn compute_exhaustive_switch_statement(&mut self, node: P<Node>) -> bool | flow.go:1949 | Checker
compute_flow_memo_key | fn compute_flow_memo_key(&mut self, f: P<FlowState>) -> Option<u128> | rust:flowmemo.rs:508 | Checker
compute_hashed_flow_memo_key | fn compute_hashed_flow_memo_key(&mut self, f: P<FlowState>) -> Option<u128> | rust:flowmemo.rs:525 | Checker
compute_is_uniform_union_type | pub(crate) fn compute_is_uniform_union_type(&mut self, types: &[P<Type>]) -> bool | checker.go:28300 | Checker
compute_key_property_name_and_map | pub(crate) fn compute_key_property_name_and_map(&mut self, t: P<Type>) -> (String, FxHashMap<P<Type>, P<Type>>) | relater.go:1132 | Checker
conditional_type_to_type_node | pub(crate) fn conditional_type_to_type_node(&self, c: &mut Checker, typ: P<Type>) -> P<Node> | nodebuilderimpl.go:3009 | NodeBuilderImpl
constituent_flags | fn constituent_flags(&mut self, t: P<Type>) -> TypeFlags | rust:checker_13.rs:2702 | Checker
constituent_map | pub fn constituent_map(&self) -> Option<&'static GoMap<P<Type>, P<Type>>> | rust:types.rs:2682 | UnionType
constituent_map_for_write | pub fn constituent_map_for_write(&self) -> &'static GoMap<P<Type>, P<Type>> | rust:types.rs:2687 | UnionType
constraint_type | pub fn constraint_type(&self) -> Option<P<Type>> | rust:types.rs:2454 | MappedType
construct_signatures | pub fn construct_signatures(&self) -> &'static [P<Signature>] | rust:types.rs:2174 | StructuredType
constructor_visibilities_are_compatible | pub(crate) fn constructor_visibilities_are_compatible(&self, c: &mut Checker, source_signature: P<Signature>, target_signature: P<Signature>, report_errors: bool) -> bool | relater.go:4550 | Relater
container_allows_block_scoped_variable | pub(crate) fn container_allows_block_scoped_variable(parent: P<Node>) -> bool | grammarchecks.go:1796 | Checker
container_seems_to_be_empty_dom_element | pub(crate) fn container_seems_to_be_empty_dom_element(&mut self, containing_type: P<Type>) -> bool | checker.go:11855 | Checker
containing_type | pub fn containing_type(&self) -> Option<P<Type>> | rust:types.rs:481 | ValueSymbolLinks
contains | fn contains(self, identity: RecursionId) -> bool | rust:checker_13.rs:773 | BaseConstraintStack
contains | pub fn contains(&self, item: &T) -> bool | rust:checker.rs:569 | LazyVec
contains | pub(crate) fn contains(&self, value: T) -> bool | utilities.go:884 | orderedSet
contains_arguments_reference | pub(crate) fn contains_arguments_reference(&mut self, node: P<Node>) -> bool | checker.go:32615 | Checker
contains_key | pub fn contains_key(&self, key: &K) -> bool | rust:basedmap.rs:81 | Based
contains_key | pub fn contains_key(&self, key: &K) -> bool | rust:packedmap.rs:78 | PackedMap
contains_matching_reference | pub(crate) fn contains_matching_reference(&mut self, source: P<Node>, target: P<Node>) -> bool | flow.go:1841 | Checker
contains_missing_type | pub(crate) fn contains_missing_type(&self, t: P<Type>) -> bool | rust:checker.rs:2435 | Checker
contains_non_missing_undefined_type | pub(crate) fn contains_non_missing_undefined_type(c: &Checker, t: P<Type>) -> bool | utilities.go:1647 | -
contains_regular_literal_type | fn contains_regular_literal_type(c: &mut Checker, types: &[P<Type>], i: usize, regular: P<Type>) -> bool | rust:checker_13.rs:1379 | -
contains_same_named_this_property | pub(crate) fn contains_same_named_this_property(&mut self, this_property: P<Node>, expression: P<Node>) -> bool | checker.go:18496 | Checker
contains_type | pub(crate) fn contains_type(c: &mut Checker, types: &[P<Type>], t: P<Type>) -> bool | checker.go:27086 | -
contains_undefined_type | pub(crate) fn contains_undefined_type(t: P<Type>) -> bool | checker.go:28324 | Checker
contextual_property_type_of_constituent | fn contextual_property_type_of_constituent(&mut self, t: P<Type>, name: &str, name_type: Option<P<Type>>) -> Option<P<Type>> | rust:checker_15.rs:667 | Checker
contextual_property_type_of_large_union | fn contextual_property_type_of_large_union(&mut self, t: P<Type>, name: &str, name_type: Option<P<Type>>) -> Option<Option<P<Type>>> | rust:checker_15.rs:732 | Checker
contextually_check_function_expression_or_object_literal_method | pub(crate) fn contextually_check_function_expression_or_object_literal_method(&mut self, node: P<Node>, check_mode: CheckMode) | checker.go:10347 | Checker
convert_auto_to_any | pub(crate) fn convert_auto_to_any(&self, t: P<Type>) -> P<Type> | checker.go:31705 | Checker
copy_cells_bitwise | pub unsafe fn copy_cells_bitwise<V>(dst: &V, src: &V) | rust:links.rs:147 | -
could_access_optional_property | pub(crate) fn could_access_optional_property(&mut self, object_type: P<Type>, index_type: P<Type>) -> bool | checker.go:29796 | Checker
could_contain_type_variables | pub(crate) fn could_contain_type_variables(&mut self, t: P<Type>) -> bool | rust:checker.rs:2441 | Checker
could_contain_type_variables_worker | pub(crate) fn could_contain_type_variables_worker(&mut self, t: P<Type>) -> bool | checker.go:22609 | Checker
count | fn count(on: bool, counter: &AtomicU64, n: u64) | rust:infermemo.rs:145 | -
count | fn count(on: bool, counter: &AtomicU64) | rust:unioncache.rs:174 | -
count | pub fn count(&mut self, cat: Cat, key: CKey, a: u64, b: u64, c: u64) | rust:workcensus.rs:319 | Census
count_bypass | fn count_bypass(cache: &UnionFrontCache) | rust:unioncache.rs:164 | -
count_bypass_origin | pub(crate) fn count_bypass_origin(cache: &UnionFrontCache) | rust:unioncache.rs:159 | -
count_global_symbols | pub(crate) fn count_global_symbols(files: &[P<SourceFile>]) -> usize | checker.go:1136 | -
count_lists | fn count_lists(&mut self, total: usize) | rust:checker_11.rs:341 | NameCounts
count_types | pub(crate) fn count_types(t: P<Type>) -> usize | checker.go:27098 | -
create | fn create(&mut self, id: u64) -> P<V> | rust:links.rs:487 | IdLinkStore
create | fn create(&mut self, id: u64) -> &'static V | rust:links.rs:627 | InlineIdStore
create | fn create(&mut self, key: PKey) -> P<V> | rust:links.rs:267 | KeyedLinkStore
create | fn create(&mut self, key: PKey) -> P<V> | rust:links.rs:120 | LinkStore
create_access_expression | pub(crate) fn create_access_expression(&self, node: P<Node>) -> P<Node> | nodebuilderimpl.go:3651 | NodeBuilderImpl
create_access_from_symbol_chain | pub(crate) fn create_access_from_symbol_chain(&self, c: &mut Checker, chain: &[P<Symbol>], index: usize, stopper: usize, override_type_arguments: Option<P<NodeList>>) -> P<Node> | nodebuilderimpl.go:752 | NodeBuilderImpl
create_anonymous_type_node | pub(crate) fn create_anonymous_type_node(&self, c: &mut Checker, t: P<Type>) -> Option<P<Node>> | nodebuilderimpl.go:2890 | NodeBuilderImpl
create_anonymous_type_node_ex | pub(crate) fn create_anonymous_type_node_ex(&self, c: &mut Checker, t: P<Type>, force_class_expansion: bool, force_expansion: bool) -> Option<P<Node>> | nodebuilderimpl.go:2905 | NodeBuilderImpl
create_array_literal_type | pub(crate) fn create_array_literal_type(&mut self, t: P<Type>) -> P<Type> | checker.go:8275 | Checker
create_array_type | pub(crate) fn create_array_type(&mut self, element_type: P<Type>) -> P<Type> | checker.go:25171 | Checker
create_array_type_ex | pub(crate) fn create_array_type_ex(&mut self, element_type: P<Type>, readonly: bool) -> P<Type> | checker.go:25175 | Checker
create_awaited_type_if_needed | pub(crate) fn create_awaited_type_if_needed(&mut self, t: P<Type>) -> P<Type> | checker.go:31899 | Checker
create_canonical_signature | pub(crate) fn create_canonical_signature(&mut self, signature: P<Signature>) -> P<Signature> | checker.go:19763 | Checker
create_combined_symbol_for_overload_failure | pub(crate) fn create_combined_symbol_for_overload_failure(&mut self, sources: &[P<Symbol>], t: P<Type>) -> P<Symbol> | checker.go:9818 | Checker
create_combined_symbol_from_types | pub(crate) fn create_combined_symbol_from_types(&mut self, sources: &[P<Symbol>], types: &[P<Type>]) -> P<Symbol> | checker.go:9814 | Checker
create_computed_enum_type | pub(crate) fn create_computed_enum_type(&mut self, symbol: P<Symbol>) -> P<Type> | checker.go:24387 | Checker
create_default_property_wrapper_for_module | pub(crate) fn create_default_property_wrapper_for_module(&mut self, symbol: P<Symbol>, original_symbol: Option<P<Symbol>>, anonymous_symbol: Option<P<Symbol>>) -> P<Type> | checker.go:16030 | Checker
create_deferred_type_reference | pub(crate) fn create_deferred_type_reference(&mut self, target: P<Type>, node: P<Node>, mapper: Option<P<TypeMapper>>, alias: Option<P<TypeAlias>>) -> P<Type> | checker.go:25591 | Checker
create_diagnostic_chain_from_error_chain | pub(crate) fn create_diagnostic_chain_from_error_chain(chain: Option<P<ErrorChain>>, error_node: P<Node>, related_info: &[P<Diagnostic>]) -> Option<P<Diagnostic>> | relater.go:400 | -
create_diagnostic_for_node | pub(crate) fn create_diagnostic_for_node(node: Option<P<Node>>, message: &'static Message, args: &[&dyn Display]) -> P<Diagnostic> | checker.go:14493 | -
create_elided_information_placeholder | pub(crate) fn create_elided_information_placeholder(&self, _c: &mut Checker) -> P<Node> | nodebuilderimpl.go:341 | NodeBuilderImpl
create_empty_object_type_from_string_literal | pub(crate) fn create_empty_object_type_from_string_literal(&mut self, t: P<Type>) -> P<Type> | inference.go:1229 | Checker
create_entity_name_from_symbol_chain | pub(crate) fn create_entity_name_from_symbol_chain(&self, c: &mut Checker, chain: &[P<Symbol>], index: usize) -> P<Node> | nodebuilderimpl.go:614 | NodeBuilderImpl
create_expression_from_symbol_chain | pub(crate) fn create_expression_from_symbol_chain(&self, c: &mut Checker, chain: &[P<Symbol>], index: usize) -> P<Node> | nodebuilderimpl.go:858 | NodeBuilderImpl
create_expression_with_type_arguments | pub(crate) fn create_expression_with_type_arguments(&self, _c: &mut Checker, expr: P<Node>, type_arguments: Option<P<NodeList>>) -> P<Node> | nodebuilderimpl.go:3662 | NodeBuilderImpl
create_file_index_map | pub(crate) fn create_file_index_map(files: &[P<SourceFile>]) -> FxHashMap<P<SourceFile>, usize> | checker.go:1128 | -
create_final_array_type | pub(crate) fn create_final_array_type(&mut self, element_type: P<Type>) -> P<Type> | flow.go:1580 | Checker
create_generator_type | pub(crate) fn create_generator_type(&mut self, yield_type: P<Type>, return_type: P<Type>, next_type: P<Type>, is_async_generator: bool) -> P<Type> | checker.go:20775 | Checker
create_import_attributes_for_module_specifier | pub(crate) fn create_import_attributes_for_module_specifier(&self, c: &mut Checker, result: moduleSpecifierResult, import_mode_override: ModuleKind) -> Option<P<Node>> | nodebuilderimpl.go:1359 | NodeBuilderImpl
create_instantiated_symbol_table | pub(crate) fn create_instantiated_symbol_table(&mut self, symbols: &[P<Symbol>], m: P<TypeMapper>) -> Option<P<SymbolTable>> | checker.go:21070 | Checker
create_iterable_type | pub(crate) fn create_iterable_type(&mut self, iterated_type: P<Type>) -> P<Type> | checker.go:25167 | Checker
create_jsx_attributes_type_from_attributes_property | pub(crate) fn create_jsx_attributes_type_from_attributes_property(&mut self, opening_like_element: P<Node>, check_mode: CheckMode) -> P<Type> | jsx.go:710 | Checker
create_late_bound_index_signatures | pub fn create_late_bound_index_signatures(&self, c: &mut Checker, emit_context: P<EmitContext>, container: P<Node>, enclosing_declaration: Option<P<Node>>, flags: Flags, internal_flags: InternalFlags, tracker: &'static dyn SymbolTracker) -> Vec<P<Node>> | emitresolver.go:1061 | EmitResolver
create_lazy_member_table | fn create_lazy_member_table(&mut self, t: P<Type>, source: P<Type>) -> Option<P<LazyMemberTable>> | rust:checker_09.rs:2937 | Checker
create_literal_const_value | pub fn create_literal_const_value(&self, c: &mut Checker, emit_context: P<EmitContext>, node: P<Node>, tracker: &'static dyn SymbolTracker) -> Option<P<Node>> | emitresolver.go:988 | EmitResolver
create_mapped_type_node_from_type | pub(crate) fn create_mapped_type_node_from_type(&self, c: &mut Checker, t: P<Type>) -> P<Node> | nodebuilderimpl.go:1530 | NodeBuilderImpl
create_marker_type | pub(crate) fn create_marker_type(&mut self, symbol: P<Symbol>, source: P<Type>, target: P<Type>) -> P<Type> | relater.go:1446 | Checker
create_mode_mismatch_details | pub fn create_mode_mismatch_details(program: &'static dyn Program, file: P<SourceFile>) -> DiagnosticDetails | utilities.go:1875 | -
create_mode_mismatch_details | pub(crate) fn create_mode_mismatch_details(&self, source_file: P<SourceFile>, error_node: P<Node>) -> P<Diagnostic> | checker.go:15838 | Checker
create_module_not_found_chain | pub fn create_module_not_found_chain(program: &'static dyn Program, file: P<SourceFile>, module_reference: &str, mode: ModuleKind, package_name: &str) -> DiagnosticDetails | utilities.go:1839 | -
create_module_not_found_chain | pub(crate) fn create_module_not_found_chain(&self, resolved_module: P<ResolvedModule>, error_node: P<Node>, module_reference: &str, mode: ModuleKind, package_name: &str) -> P<Diagnostic> | checker.go:15820 | Checker
create_name_resolver | pub(crate) fn create_name_resolver(&self) -> P<NameResolver<Checker>> | checker.go:1507 | Checker
create_name_resolver_for_suggestion | pub(crate) fn create_name_resolver_for_suggestion(&self) -> P<NameResolver<Checker>> | checker.go:1525 | Checker
create_normalized_tuple_type | pub(crate) fn create_normalized_tuple_type(&mut self, target: P<Type>, element_types: &[P<Type>]) -> P<Type> | checker.go:23812 | Checker
create_normalized_tuple_type_ex | pub(crate) fn create_normalized_tuple_type_ex(&mut self, target: P<Type>, element_types: &[P<Type>], object_flags: ObjectFlags) -> P<Type> | checker.go:23764 | Checker
create_normalized_type_reference | pub(crate) fn create_normalized_type_reference(&mut self, target: P<Type>, type_arguments: &[P<Type>]) -> P<Type> | checker.go:23757 | Checker
create_object_literal_type | fn create_object_literal_type(c: &mut Checker, node: P<Node>, st: &ObjectLiteralState) -> P<Type> | rust:checker_07.rs:47 | -
create_outer_return_mapper | pub(crate) fn create_outer_return_mapper(context: P<InferenceContext>) -> P<TypeMapper> | inference.go:1423 | Checker
create_printer_with_defaults | pub(crate) fn create_printer_with_defaults(emit_context: P<EmitContext>) -> Printer | printer.go:13 | -
create_printer_with_remove_comments | pub(crate) fn create_printer_with_remove_comments(emit_context: P<EmitContext>) -> Printer | printer.go:17 | -
create_printer_with_remove_comments_omit_trailing_semicolon | pub(crate) fn create_printer_with_remove_comments_omit_trailing_semicolon(emit_context: P<EmitContext>) -> Printer | printer.go:21 | -
create_printer_with_remove_comments_omit_trailing_semicolon_never_ascii_escape | pub(crate) fn create_printer_with_remove_comments_omit_trailing_semicolon_never_ascii_escape(emit_context: P<EmitContext>) -> Printer | printer.go:28 | -
create_promise_like_type | pub(crate) fn create_promise_like_type(&mut self, promised_type: P<Type>) -> P<Type> | checker.go:20701 | Checker
create_promise_return_type | pub(crate) fn create_promise_return_type(&mut self, fn_: P<Node>, promised_type: P<Type>) -> P<Type> | checker.go:20713 | Checker
create_promise_type | pub(crate) fn create_promise_type(&mut self, promised_type: P<Type>) -> P<Type> | checker.go:20689 | Checker
create_property_name_node_for_identifier_or_literal | pub(crate) fn create_property_name_node_for_identifier_or_literal(&self, c: &mut Checker, name: &str, single_quote: bool, string_named: bool, is_method: bool, symbol: P<Symbol>) -> P<Node> | nodebuilderimpl.go:2466 | NodeBuilderImpl
create_recovery_boundary | pub(crate) fn create_recovery_boundary(&self, c: &Checker) -> P<recoveryBoundary> | nodecopy.go:195 | NodeBuilderImpl
create_return_type_of_signature_declaration | pub fn create_return_type_of_signature_declaration(&self, c: &mut Checker, emit_context: P<EmitContext>, signature_declaration: P<Node>, enclosing_declaration: Option<P<Node>>, flags: Flags, internal_flags: InternalFlags, tracker: &'static dyn SymbolTracker) -> Option<P<Node>> | emitresolver.go:950 | EmitResolver
create_reverse_mapped_type | pub(crate) fn create_reverse_mapped_type(&mut self, source: P<Type>, target: P<Type>, constraint: P<Type>) -> Option<P<Type>> | inference.go:1014 | Checker
create_signature_for_jsx_intrinsic | pub(crate) fn create_signature_for_jsx_intrinsic(&mut self, node: P<Node>, result: P<Type>) -> P<Signature> | jsx.go:1171 | Checker
create_signature_instantiation | pub(crate) fn create_signature_instantiation(&mut self, sig: P<Signature>, type_arguments: &[P<Type>]) -> P<Signature> | checker.go:19669 | Checker
create_signature_type_mapper | pub(crate) fn create_signature_type_mapper(&mut self, sig: P<Signature>, type_arguments: &[P<Type>]) -> P<TypeMapper> | checker.go:19673 | Checker
create_symbol_table | pub(crate) fn create_symbol_table(symbols: &[P<Symbol>]) -> Option<P<SymbolTable>> | utilities.go:350 | -
create_symbol_with_type | pub(crate) fn create_symbol_with_type(&mut self, source: P<Symbol>, t: Option<P<Type>>) -> P<Symbol> | checker.go:22065 | Checker
create_synthetic_expression | pub(crate) fn create_synthetic_expression(&self, parent: P<Node>, t: P<Type>, is_spread: bool, tuple_name_source: Option<P<Node>>) -> P<Node> | checker.go:30605 | Checker
create_tuple_target_type | pub(crate) fn create_tuple_target_type(&mut self, element_infos: &[TupleElementInfo], readonly: bool) -> P<Type> | checker.go:25245 | Checker
create_tuple_type | pub(crate) fn create_tuple_type(&mut self, element_types: &[P<Type>]) -> P<Type> | checker.go:25205 | Checker
create_tuple_type_ex | pub(crate) fn create_tuple_type_ex(&mut self, element_types: &[P<Type>], element_infos: &[TupleElementInfo], readonly: bool) -> P<Type> | checker.go:25210 | Checker
create_type_from_generic_global_type | pub(crate) fn create_type_from_generic_global_type(&mut self, generic_global_type: P<Type>, type_arguments: &[P<Type>]) -> P<Type> | checker.go:25138 | Checker
create_type_node_from_object_type | pub(crate) fn create_type_node_from_object_type(&self, c: &mut Checker, t: P<Type>) -> Option<P<Node>> | nodebuilderimpl.go:2782 | NodeBuilderImpl
create_type_nodes_from_resolved_type | pub(crate) fn create_type_nodes_from_resolved_type(&self, c: &mut Checker, resolved_type: P<Type>) -> Option<P<NodeList>> | nodebuilderimpl.go:2719 | NodeBuilderImpl
create_type_of_declaration | pub fn create_type_of_declaration(&self, c: &mut Checker, emit_context: P<EmitContext>, declaration: P<Node>, enclosing_declaration: Option<P<Node>>, flags: Flags, internal_flags: InternalFlags, tracker: &'static dyn SymbolTracker) -> Option<P<Node>> | emitresolver.go:974 | EmitResolver
create_type_of_expression | pub fn create_type_of_expression(&self, c: &mut Checker, emit_context: P<EmitContext>, expression: P<Node>, enclosing_declaration: Option<P<Node>>, flags: Flags, internal_flags: InternalFlags, tracker: &'static dyn SymbolTracker) -> Option<P<Node>> | emitresolver.go:1049 | EmitResolver
create_type_parameters_of_signature_declaration | pub fn create_type_parameters_of_signature_declaration(&self, c: &mut Checker, emit_context: P<EmitContext>, signature_declaration: P<Node>, enclosing_declaration: Option<P<Node>>, flags: Flags, internal_flags: InternalFlags, tracker: &'static dyn SymbolTracker) -> Option<Vec<P<Node>>> | emitresolver.go:962 | EmitResolver
create_type_predicate_from_type_predicate_node | pub(crate) fn create_type_predicate_from_type_predicate_node(&mut self, node: P<Node>, signature: P<Signature>) -> P<TypePredicate> | relater.go:2117 | Checker
create_type_reference | pub(crate) fn create_type_reference(&mut self, target: P<Type>, type_arguments: &[P<Type>]) -> P<Type> | checker.go:25573 | Checker
create_type_reference_ex | pub(crate) fn create_type_reference_ex(&mut self, target: P<Type>, type_arguments: &[P<Type>], object_flags: ObjectFlags) -> P<Type> | checker.go:25577 | Checker
create_union_of_signatures_for_overload_failure | pub(crate) fn create_union_of_signatures_for_overload_failure(&mut self, candidates: &[P<Signature>]) -> P<Signature> | checker.go:9773 | Checker
create_union_or_intersection_property | pub(crate) fn create_union_or_intersection_property(&mut self, containing_type: P<Type>, name: &str, skip_object_function_property_augment: bool) -> Option<P<Symbol>> | checker.go:21793 | Checker
create_union_signature | pub(crate) fn create_union_signature(&mut self, sig: P<Signature>, union_signatures: &[P<Signature>]) -> P<Signature> | checker.go:10492 | Checker
create_unknown_union_type | pub(crate) fn create_unknown_union_type(&mut self) -> P<Type> | checker.go:25506 | Checker
create_widening_type | pub(crate) fn create_widening_type(&mut self, non_widening_type: P<Type>) -> P<Type> | checker.go:25497 | Checker
ctx | pub fn ctx(&self) -> P<NodeBuilderContext> | rust:nodebuilder_types.rs:195 | NodeBuilderImpl
data | pub fn data(&self) -> TypeData | rust:types.rs:1419 | Type
data | pub fn data(&self) -> TypeMapperData | rust:mapper.rs:222 | TypeMapper
data_tag | pub fn data_tag(&self) -> TypeDataTag | rust:types.rs:1445 | Type
declaration | pub fn declaration(&self) -> Option<P<Node>> | rust:types.rs:3167 | IndexInfo
declaration | pub fn declaration(&self) -> Option<P<Node>> | rust:types.rs:3021 | Signature
declaration_belongs_to_private_ambient_member | pub(crate) fn declaration_belongs_to_private_ambient_member(declaration: P<Node>) -> bool | utilities.go:333 | -
declaration_belongs_to_private_ambient_member | pub(crate) fn declaration_belongs_to_private_ambient_member(declaration: P<Node>) -> bool | checker.go:18373 | Checker
declared | fn declared(&self) -> P<Type> | rust:flow.rs:23 | FlowState
declared_parameter_type_contains_undefined | pub(crate) fn declared_parameter_type_contains_undefined(&self, c: &mut Checker, parameter: P<Node>) -> bool | emitresolver.go:609 | EmitResolver
defer_type_argument_constraints | fn defer_type_argument_constraints(&mut self, node: P<Node>) -> bool | rust:checker_02.rs:1062 | Checker
delete | pub fn delete(&self, key: &K) | rust:types.rs:120 | GoMap
dense_slot | fn dense_slot(dense: P<[Cell<u32>; ID_GROUP]>, i: usize) -> Option<u32> | rust:links.rs:444 | IdLinkStore
describe | fn describe(t: P<Type>) -> String | rust:uniontrace.rs:128 | -
describe_into | fn describe_into(t: P<Type>, depth: u32, out: &mut String) | rust:uniontrace.rs:134 | -
describe_symbol | fn describe_symbol(symbol: P<Symbol>, out: &mut String) | rust:uniontrace.rs:180 | -
determine_if_declaration_is_visible | pub(crate) fn determine_if_declaration_is_visible(&self, c: &mut Checker, node: P<Node>) -> bool | emitresolver.go:131 | EmitResolver
discriminant_property_types | fn discriminant_property_types(&mut self, target: P<Type>, types: &[P<Type>], name: &str) -> Option<std::rc::Rc<[Option<Option<P<Type>>>]>> | rust:relater_1.rs:1958 | Checker
discriminate_contextual_type_by_jsx_attributes | pub(crate) fn discriminate_contextual_type_by_jsx_attributes(&mut self, node: P<Node>, contextual_type: P<Type>) -> P<Type> | jsx.go:266 | Checker
discriminate_contextual_type_by_object_members | pub(crate) fn discriminate_contextual_type_by_object_members(&mut self, node: P<Node>, contextual_type: P<Type>) -> P<Type> | checker.go:31244 | Checker
discriminate_type_by_discriminable_items | pub(crate) fn discriminate_type_by_discriminable_items(&mut self, target: P<Type>, discriminator: &mut dyn Discriminator) -> P<Type> | relater.go:1205 | Checker
distribute_index_over_object_type | pub(crate) fn distribute_index_over_object_type(&mut self, object_type: P<Type>, index_type: P<Type>, writing: bool) -> Option<P<Type>> | checker.go:28460 | Checker
distribute_object_over_index_type | pub(crate) fn distribute_object_over_index_type(&mut self, object_type: P<Type>, index_type: P<Type>, writing: bool) -> Option<P<Type>> | checker.go:28445 | Checker
does_accessor_have_correct_parameter_count | pub(crate) fn does_accessor_have_correct_parameter_count(accessor: P<Node>) -> bool | grammarchecks.go:1345 | Checker
dump | pub fn dump() | rust:sitecount.rs:87 | -
each_type_contained_in | pub(crate) fn each_type_contained_in(source: P<Type>, types: &[P<Type>]) -> bool | flow.go:1978 | Checker
each_type_related_to_some_type | pub(crate) fn each_type_related_to_some_type(&self, c: &mut Checker, source: P<Type>, target: P<Type>) -> Ternary | relater.go:3076 | Relater
each_type_related_to_type | pub(crate) fn each_type_related_to_type(&self, c: &mut Checker, source: P<Type>, target: P<Type>, report_errors: bool, intersection_state: IntersectionState) -> Ternary | relater.go:2965 | Relater
each_union_contains | pub(crate) fn each_union_contains(&mut self, union_types: &[P<Type>], t: P<Type>) -> bool | checker.go:26866 | Checker
earliest_declaration | fn earliest_declaration(&mut self, t: P<Type>) -> Option<P<Node>> | rust:checker_09.rs:3378 | Checker
elaborate_array_literal | pub(crate) fn elaborate_array_literal(&mut self, node: P<Node>, source: P<Type>, target: P<Type>, relation: P<Relation>, diagnostic_output: Option<&mut Vec<P<Diagnostic>>>) -> bool | relater.go:520 | Checker
elaborate_arrow_function | pub(crate) fn elaborate_arrow_function(&mut self, node: P<Node>, source: P<Type>, target: P<Type>, relation: P<Relation>, diagnostic_output: Option<&mut Vec<P<Diagnostic>>>) -> bool | relater.go:639 | Checker
elaborate_did_you_mean_to_call_or_construct | pub(crate) fn elaborate_did_you_mean_to_call_or_construct(&mut self, node: P<Node>, source: P<Type>, target: P<Type>, relation: P<Relation>, kind: SignatureKind, head_message: Option<&'static Message>, diagnostic_output: Option<&mut Vec<P<Diagnostic>>>) -> bool | relater.go:478 | Checker
elaborate_element | pub(crate) fn elaborate_element(&mut self, source: P<Type>, target: P<Type>, relation: P<Relation>, prop: P<Node>, next: Option<P<Node>>, name_type: P<Type>, error_message: Option<&'static Message>, diagnostic_factory: Option<&mut dyn FnMut(&mut Checker, P<Node>) -> P<Diagnostic>>, diagnostic_output: Option<&mut Vec<P<Diagnostic>>>) -> bool | relater.go:544 | Checker
elaborate_error | pub(crate) fn elaborate_error(&mut self, node: Option<P<Node>>, source: P<Type>, target: P<Type>, relation: P<Relation>, head_message: Option<&'static Message>, diagnostic_output: Option<&mut Vec<P<Diagnostic>>>) -> bool | relater.go:438 | Checker
elaborate_iterable_or_array_like_target_elementwise | pub(crate) fn elaborate_iterable_or_array_like_target_elementwise(&mut self, iterator: impl FnMut(&mut Checker) -> Option<JsxElaborationElement>, source: P<Type>, target: P<Type>, relation: P<Relation>, diagnostic_output: Option<&mut Vec<P<Diagnostic>>>) -> bool | jsx.go:420 | Checker
elaborate_jsx_components | pub(crate) fn elaborate_jsx_components(&mut self, node: P<Node>, source: P<Type>, target: P<Type>, relation: P<Relation>, diagnostic_output: Option<&mut Vec<P<Diagnostic>>>) -> bool | jsx.go:296 | Checker
elaborate_never_intersection | pub(crate) fn elaborate_never_intersection(&mut self, chain: Option<P<Diagnostic>>, node: P<Node>, t: P<Type>) -> Option<P<Diagnostic>> | checker.go:22264 | Checker
elaborate_object_literal | pub(crate) fn elaborate_object_literal(&mut self, node: P<Node>, source: P<Type>, target: P<Type>, relation: P<Relation>, diagnostic_output: Option<&mut Vec<P<Diagnostic>>>) -> bool | relater.go:496 | Checker
element_flags | pub fn element_flags(&self) -> Vec<ElementFlags> | rust:types.rs:2412 | TupleType
element_infos | pub fn element_infos(&self) -> &'static [TupleElementInfo] | rust:types.rs:2416 | TupleType
emit_context | pub fn emit_context(&self) -> P<EmitContext> | nodebuilder.go:29 | NodeBuilder
emit_module_format_of_file | pub(crate) fn emit_module_format_of_file(&mut self, file: P<SourceFile>) -> ModuleKind | rust:checker_09.rs:2413 | Checker
enabled | pub(crate) fn enabled() -> bool | rust:uniontrace.rs:30 | -
enclosing_declaration_name | fn enclosing_declaration_name(node: P<Node>) -> String | rust:workcensus.rs:415 | -
end | pub fn end(&mut self, span: Span) -> Timing | rust:workcensus.rs:252 | Census
end | fn end(&mut self, frame: FlowFrame) -> (FrameTaint, u16) | rust:flowmemo.rs:273 | FlowMemo
end_instantiation_count | pub(crate) fn end_instantiation_count(&mut self) | rust:checker_04.rs:1550 | Checker
end_recovery_scope | pub(crate) fn end_recovery_scope(&self, state: originalRecoveryScopeState) | nodecopy.go:128 | recoveryBoundary
end_transparent | pub(crate) fn end_transparent(&mut self, frame: FlowFrame) -> (FrameTaint, u16, u8) | rust:flowmemo.rs:259 | FlowMemo
end_with | fn end_with(&mut self, frame: FlowFrame, height: u16) -> FrameTaint | rust:flowmemo.rs:239 | FlowMemo
ensure_assignments_marked | pub(crate) fn ensure_assignments_marked(&mut self, symbol: P<Symbol>) | flow.go:2674 | Checker
enter_context | pub(crate) fn enter_context(&self, enclosing_declaration: Option<P<Node>>, flags: Flags, internal_flags: InternalFlags, tracker: Option<&'static dyn SymbolTracker>) | nodebuilder.go:33 | NodeBuilder
enter_new_scope | pub(crate) fn enter_new_scope(&self, c: &mut Checker, declaration: Option<P<Node>>, expanded_params: &[P<Symbol>], type_parameters: &[P<Type>], original_parameters: Option<&[P<Symbol>]>, mapper: Option<P<TypeMapper>>) -> Box<dyn FnMut(&mut Checker)> | nodebuilderscopes.go:59 | NodeBuilderImpl
enter_signature_scope | pub(crate) fn enter_signature_scope(&self, c: &mut Checker, signature: P<Signature>) -> (Vec<P<Symbol>>, Box<dyn FnMut(&mut Checker)>) | nodebuilderscopes.go:53 | NodeBuilderImpl
enter_synthetic_mode | fn enter_synthetic_mode(&self) -> bool | rust:types.rs:435 | ValueSymbolLinks
entity_name_to_string | pub(crate) fn entity_name_to_string(name: P<Node>) -> String | utilities.go:217 | -
entries | pub fn entries(&self) -> Vec<(K, V)> | rust:types.rs:171 | GoMap
enum_member_initializer | pub(crate) fn enum_member_initializer(&self, c: &mut Checker, p: P<Symbol>) -> Option<P<Node>> | nodebuilder_hover.go:92 | NodeBuilderImpl
env_mode | fn env_mode() -> Option<InferMemoMode> | rust:infermemo.rs:64 | -
env_mode | fn env_mode() -> Option<UnionCacheMode> | rust:unioncache.rs:48 | -
erase | fn erase<T>(p: Option<P<T>>) -> Option<P<()>> | rust:types.rs:380 | -
error | pub(crate) fn error(&mut self, location: Option<P<Node>>, message: &'static Message, args: &[&dyn Display]) -> P<Diagnostic> | checker.go:14237 | Checker
error_and_maybe_suggest_await | pub(crate) fn error_and_maybe_suggest_await(&mut self, location: Option<P<Node>>, maybe_missing_await: bool, message: &'static Message, args: &[&dyn Display]) -> P<Diagnostic> | checker.go:14251 | Checker
error_if_writing_to_readonly_index | pub(crate) fn error_if_writing_to_readonly_index(&mut self, index_info: Option<P<IndexInfo>>, object_type: P<Type>, access_expression: Option<P<Node>>) | checker.go:27739 | Checker
error_next_variable_or_property_declaration_must_have_same_type | pub(crate) fn error_next_variable_or_property_declaration_must_have_same_type(&mut self, first_declaration: Option<P<Node>>, first_type: P<Type>, next_declaration: P<Node>, next_type: P<Type>) | checker.go:6119 | Checker
error_no_module_member_symbol | pub(crate) fn error_no_module_member_symbol(&mut self, module_symbol: P<Symbol>, target_symbol: P<Symbol>, node: P<Node>, name: P<Node>) | checker.go:15127 | Checker
error_on_implicit_any_module | pub(crate) fn error_on_implicit_any_module(&mut self, is_error: bool, error_node: P<Node>, mode: ModuleKind, resolved_module: P<ResolvedModule>, module_reference: &str) | checker.go:15799 | Checker
error_or_suggestion | pub(crate) fn error_or_suggestion(&mut self, is_error: bool, location: Option<P<Node>>, message: &'static Message, args: &[&dyn Display]) | checker.go:14247 | Checker
error_skipped_on_no_emit | pub(crate) fn error_skipped_on_no_emit(&mut self, location: P<Node>, message: &'static Message, args: &[&dyn Display]) -> P<Diagnostic> | checker.go:14241 | Checker
escape | pub(crate) fn escape(&self) | rust:checker.rs:372 | InferenceContext
escape_mapper | pub(crate) fn escape_mapper(m: P<TypeMapper>) | rust:mapper.rs:332 | -
escaped | pub(crate) fn escaped(&self) -> bool | rust:checker.rs:367 | InferenceContext
escaped | pub fn escaped(&self) -> bool | rust:mapper.rs:246 | TypeMapper
evaluate | pub fn evaluate<H>(host: &mut H, evaluate_entity: Evaluator<H>, outer_expressions_to_skip: ast::OuterExpressionKinds, expr: P<Node>, location: P<Node>) -> Result | rust:evaluator.rs:22 | -
evaluate | pub(crate) fn evaluate(&mut self, expr: P<Node>, location: P<Node>) -> evaluator::Result | rust:checker.rs:2427 | Checker
evaluate_entity | pub(crate) fn evaluate_entity(&mut self, expr: P<Node>, location: Option<P<Node>>) -> evaluator::Result | checker.go:24494 | Checker
evaluate_enum_member | pub(crate) fn evaluate_enum_member(&mut self, expr: P<Node>, symbol: P<Symbol>, location: P<Node>) -> evaluator::Result | checker.go:24547 | Checker
evaluate_template_expression | fn evaluate_template_expression<H>(host: &mut H, evaluate_entity: Evaluator<H>, outer_expressions_to_skip: ast::OuterExpressionKinds, expr: P<Node>, location: P<Node>) -> Result | rust:evaluator.rs:124 | -
every_contained_type | pub(crate) fn every_contained_type(c: &mut Checker, t: P<Type>, f: impl FnMut(&mut Checker, P<Type>) -> bool) -> bool | checker.go:27021 | -
every_lazy_property | pub(crate) fn every_lazy_property(&mut self, t: P<Type>, lm: P<LazyMemberTable>, seen: &mut FxHashSet<&'static str>, f: &mut dyn FnMut(&mut Checker, P<Symbol>) -> bool) -> bool | rust:checker_09.rs:3230 | Checker
every_property_of_structured_type | pub(crate) fn every_property_of_structured_type(&mut self, t: P<Type>, f: &mut dyn FnMut(&mut Checker, P<Symbol>) -> bool) -> bool | rust:checker_09.rs:3210 | Checker
every_type | pub(crate) fn every_type(c: &mut Checker, t: P<Type>, f: impl FnMut(&mut Checker, P<Type>) -> bool) -> bool | checker.go:27014 | -
exclude_properties | pub(crate) fn exclude_properties<'a>(properties: &'a [P<Symbol>], excluded_properties: &Set<String>) -> std::borrow::Cow<'a, [P<Symbol>]> | relater.go:1008 | -
existing_type_node_is_not_reference_or_is_reference_with_compatible_type_argument_count | pub(crate) fn existing_type_node_is_not_reference_or_is_reference_with_compatible_type_argument_count(c: &mut Checker, existing: P<Node>, t: P<Type>) -> bool | nodebuilderimpl.go:524 | NodeBuilderImpl
exit_context | pub(crate) fn exit_context(&self, result: Option<P<Node>>) -> Option<P<Node>> | nodebuilder.go:84 | NodeBuilder
exit_context_check | pub(crate) fn exit_context_check(&self) | nodebuilder.go:104 | NodeBuilder
exit_context_slice | pub(crate) fn exit_context_slice(&self, result: Vec<P<Node>>) -> Vec<P<Node>> | nodebuilder.go:94 | NodeBuilder
expand_class_decl | pub(crate) fn expand_class_decl(&self, c: &mut Checker, symbol: P<Symbol>) -> P<Node> | nodebuilder_hover.go:111 | NodeBuilderImpl
expand_enum_decl | pub(crate) fn expand_enum_decl(&self, c: &mut Checker, symbol: P<Symbol>) -> P<Node> | nodebuilder_hover.go:52 | NodeBuilderImpl
expand_interface_decl | pub(crate) fn expand_interface_decl(&self, c: &mut Checker, symbol: P<Symbol>) -> P<Node> | nodebuilder_hover.go:234 | NodeBuilderImpl
expand_module_decl | pub(crate) fn expand_module_decl(&self, c: &mut Checker, symbol: P<Symbol>) -> P<Node> | nodebuilder_hover.go:413 | NodeBuilderImpl
expand_signature_parameters_with_tuple_members | fn expand_signature_parameters_with_tuple_members(c: &mut Checker, sig: P<Signature>, rest_type: P<Type>, rest_index: usize, rest_symbol: P<Symbol>) -> Vec<P<Symbol>> | rust:nodebuilderimpl_2.rs:196 | -
expand_symbol_for_hover | pub fn expand_symbol_for_hover(&mut self, symbol: P<Symbol>, meaning: SymbolFlags, vc: Option<P<VerbosityContext>>) -> String | printer.go:300 | Checker
expand_symbol_for_hover | pub fn expand_symbol_for_hover(&self, c: &mut Checker, symbol: P<Symbol>, meaning: SymbolFlags) -> Vec<P<Node>> | nodebuilder.go:152 | NodeBuilder
expand_symbol_for_hover | pub(crate) fn expand_symbol_for_hover(&self, c: &mut Checker, symbol: P<Symbol>) -> Vec<P<Node>> | nodebuilder_hover.go:25 | NodeBuilderImpl
exports_by_target | fn exports_by_target(&mut self, exports: P<SymbolTable>, symbol: P<Symbol>, candidates: &mut Vec<P<Symbol>>) -> bool | rust:printer.rs:928 | Checker
expression_result_is_unused | pub(crate) fn expression_result_is_unused(node: P<Node>) -> bool | utilities.go:1203 | -
extend_assignment_position | pub(crate) fn extend_assignment_position(node: Option<P<Node>>, declaration: P<Node>) -> TextPos | flow.go:2749 | Checker
extend_export_symbols | pub(crate) fn extend_export_symbols(&mut self, target: P<SymbolTable>, source: Option<P<SymbolTable>>, lookup_table: Option<&mut ExportCollisionTable>, export_node: Option<P<Node>>) | checker.go:16558 | Checker
extends_type | pub fn extends_type(&self) -> Option<P<Type>> | rust:types.rs:2908 | ConditionalType
extract_definitely_falsy_types | pub fn extract_definitely_falsy_types(&mut self, t: P<Type>) -> P<Type> | checker.go:29580 | Checker
extract_redundant_template_literals | pub(crate) fn extract_redundant_template_literals(&mut self, types: &[P<Type>]) -> (Vec<P<Type>>, bool) | checker.go:26787 | Checker
extract_types_of_kind | pub(crate) fn extract_types_of_kind(&mut self, t: P<Type>, kind: TypeFlags) -> P<Type> | checker.go:28625 | Checker
extract_unit_type | pub(crate) fn extract_unit_type(t: P<Type>) -> P<Type> | checker.go:25894 | Checker
file_and_line | fn file_and_line(node: P<Node>) -> String | rust:workcensus.rs:388 | -
file_diagnostics_so_far | pub fn file_diagnostics_so_far(&mut self, source_file: P<SourceFile>) -> Vec<P<Diagnostic>> | rust:checker_02.rs:196 | Checker
files_with_target | fn files_with_target(&self, target: P<Symbol>) -> impl Iterator<Item = u32> + '_ | rust:printer.rs:1639 | ModuleExportIndex
fill_missing_type_arguments | pub fn fill_missing_type_arguments(&mut self, type_arguments: &[P<Type>], type_parameters: &[P<Type>], min_type_argument_count: usize, is_java_script_implicit_any: bool) -> Vec<P<Type>> | checker.go:22350 | Checker
fill_missing_type_arguments_exported | pub fn fill_missing_type_arguments_exported(&mut self, type_arguments: &[P<Type>], type_parameters: &[P<Type>], min_type_argument_count: usize, is_java_script_implicit_any: bool) -> Vec<P<Type>> | exports.go:354 | Checker
filter_inherited_properties | pub(crate) fn filter_inherited_properties(c: &mut Checker, t: P<Type>, base_types: &[P<Type>], properties: &[P<Symbol>]) -> Vec<P<Symbol>> | nodebuilder_hover.go:571 | NodeBuilderImpl
filter_position | fn filter_position(symbol: P<Symbol>) -> (usize, u64) | rust:merged_symbols.rs:23 | MergedSymbols
filter_primitives_if_contains_non_primitive | pub(crate) fn filter_primitives_if_contains_non_primitive(&mut self, union_type: P<Type>) -> P<Type> | relater.go:1256 | Checker
filter_type | pub(crate) fn filter_type(&mut self, t: P<Type>, f: impl FnMut(&mut Checker, P<Type>) -> bool) -> P<Type> | checker.go:27028 | Checker
filter_types | pub(crate) fn filter_types(&mut self, types: &mut [P<Type>], predicate: impl FnMut(&mut Checker, P<Type>) -> bool) | checker.go:26940 | Checker
finalize_boundary | pub(crate) fn finalize_boundary(&self, c: &mut Checker, bound: P<recoveryBoundary>) -> bool | nodecopy.go:204 | NodeBuilderImpl
finalize_evolving_array_type | pub(crate) fn finalize_evolving_array_type(&mut self, t: P<Type>) -> P<Type> | flow.go:1566 | Checker
find_active_mapper | pub(crate) fn find_active_mapper(&self, mapper: P<TypeMapper>) -> Option<usize> | checker.go:22596 | Checker
find_applicable_index_info | pub(crate) fn find_applicable_index_info(&mut self, index_infos: &[P<IndexInfo>], key_type: P<Type>) -> Option<P<IndexInfo>> | checker.go:19363 | Checker
find_best_type_for_invokable | pub(crate) fn find_best_type_for_invokable(&mut self, source: P<Type>, union_target: P<Type>, kind: SignatureKind) -> Option<P<Type>> | relater.go:909 | Checker
find_best_type_for_object_literal | pub(crate) fn find_best_type_for_object_literal(&mut self, source: P<Type>, union_target: P<Type>) -> Option<P<Type>> | relater.go:945 | Checker
find_contextual_node | pub(crate) fn find_contextual_node(&self, node: P<Node>, include_caches: bool) -> Option<usize> | checker.go:31375 | Checker
find_discriminant_properties | pub(crate) fn find_discriminant_properties(&mut self, source_properties: &[P<Symbol>], target: P<Type>) -> Vec<P<Symbol>> | relater.go:1070 | Checker
find_first_illegal_decorator | pub(crate) fn find_first_illegal_decorator(node: P<Node>) -> Option<P<Node>> | grammarchecks.go:650 | Checker
find_first_illegal_modifier | pub(crate) fn find_first_illegal_modifier(node: P<Node>) -> Option<P<Node>> | grammarchecks.go:587 | Checker
find_first_modifier_except | pub(crate) fn find_first_modifier_except(node: P<Node>, allowed_modifier: Kind) -> Option<P<Node>> | grammarchecks.go:579 | Checker
find_first_super_call | pub(crate) fn find_first_super_call(node: P<Node>) -> Option<P<Node>> | checker.go:2935 | Checker
find_index_info | pub(crate) fn find_index_info(index_infos: &[P<IndexInfo>], key_type: P<Type>) -> Option<P<IndexInfo>> | checker.go:19499 | -
find_leftmost_type | pub(crate) fn find_leftmost_type(&mut self, types: &[P<Type>], f: impl FnMut(&mut Checker, P<Type>, P<Type>) -> bool) -> Option<P<Type>> | inference.go:1569 | Checker
find_matching_discriminant_type | pub(crate) fn find_matching_discriminant_type(&mut self, source: P<Type>, target: P<Type>, is_related_to: impl FnMut(&mut Checker, P<Type>, P<Type>) -> Ternary) -> Option<P<Type>> | relater.go:1055 | Checker
find_matching_signature | pub(crate) fn find_matching_signature(&mut self, signature_list: &[P<Signature>], signature: P<Signature>, partial_match: bool, ignore_this_types: bool, ignore_return_types: bool) -> Option<P<Signature>> | relater.go:2187 | Checker
find_matching_signatures | pub(crate) fn find_matching_signatures(&mut self, signature_lists: &[Vec<P<Signature>>], signature: P<Signature>, list_index: usize) -> Vec<P<Signature>> | relater.go:2152 | Checker
find_matching_type_reference_or_type_alias_reference | pub(crate) fn find_matching_type_reference_or_type_alias_reference(source: P<Type>, union_target: P<Type>) -> Option<P<Type>> | relater.go:891 | Checker
find_mixins | pub(crate) fn find_mixins(&mut self, types: &[P<Type>]) -> (Vec<bool>, usize) | checker.go:21706 | Checker
find_most_overlappy_type | pub(crate) fn find_most_overlappy_type(&mut self, source: P<Type>, union_target: P<Type>) -> Option<P<Type>> | relater.go:916 | Checker
find_resolution_cycle_start_index | pub(crate) fn find_resolution_cycle_start_index(&mut self, target: TypeSystemEntity, property_name: TypeSystemPropertyName) -> Option<usize> | checker.go:19127 | Checker
fingerprint | fn fingerprint<S: AsRef<str>>(items: &[S]) -> u64 | rust:uniontrace.rs:100 | -
fixed_length | pub fn fixed_length(&self) -> usize | rust:types.rs:2404 | TupleType
flags | pub fn flags(self) -> u8 | rust:flowmemo.rs:107 | MemoHit
flags | pub fn flags(&self) -> SignatureFlags | rust:types.rs:3013 | Signature
flags | pub fn flags(&self) -> TypeFlags | rust:types.rs:1457 | Type
flow_frame_begin | pub(crate) fn flow_frame_begin(&mut self) -> FlowFrame | rust:flowmemo.rs:427 | Checker
flow_frame_counters | fn flow_frame_counters(&mut self, frame: FlowFrame) | rust:flowmemo.rs:454 | Checker
flow_frame_end | pub(crate) fn flow_frame_end(&mut self, frame: FlowFrame) -> (FrameTaint, u16) | rust:flowmemo.rs:435 | Checker
flow_frame_end_with | pub(crate) fn flow_frame_end_with(&mut self, frame: FlowFrame, height: u16) -> FrameTaint | rust:flowmemo.rs:442 | Checker
flow_memo_at_node | fn flow_memo_at_node(&mut self, f: P<FlowState>, entry_flow: P<FlowNode>, flow: P<FlowNode>, flags: FlowFlags, key: u128, entry_depth: u32) -> Option<(MemoHit, bool)> | rust:flow.rs:414 | Checker
flow_memo_consult_ok | pub(crate) fn flow_memo_consult_ok(&mut self, f: P<FlowState>, hit: MemoHit) -> bool | rust:flowmemo.rs:579 | Checker
flow_memo_consume | pub(crate) fn flow_memo_consume(&mut self, transient: u32, reference: u32) | rust:flowmemo.rs:467 | Checker
flow_memo_consume_transient | fn flow_memo_consume_transient(&mut self, source: u32) | rust:flowmemo.rs:477 | Checker
flow_memo_created | fn flow_memo_created(&self) -> u32 | rust:flowmemo.rs:449 | Checker
flow_memo_fill | fn flow_memo_fill(&mut self, f: P<FlowState>, memo: FrameMemo, entry_flow: P<FlowNode>, final_flow: P<FlowNode>, entry_depth: u32, t: FlowType, taint: FrameTaint, height: u16, steps: u32, hit: Option<MemoHit>) | rust:flow.rs:465 | Checker
flow_memo_key | pub(crate) fn flow_memo_key(&mut self, f: P<FlowState>) -> Option<u128> | rust:flowmemo.rs:488 | Checker
flow_memo_lookup | fn flow_memo_lookup(&mut self, f: P<FlowState>, flow: P<FlowNode>, key: u128, entry_depth: u32) -> Option<MemoHit> | rust:flow.rs:440 | Checker
flow_memo_root_symbol | fn flow_memo_root_symbol(&self, node: P<Node>) -> Option<P<Symbol>> | rust:flowmemo.rs:549 | Checker
flow_memo_shadow_check | fn flow_memo_shadow_check(&mut self, f: P<FlowState>, entry_depth: u32, t: FlowType, taint: FrameTaint, shadow_hit: ShadowHit) | rust:flow.rs:536 | Checker
flow_memo_shadow_key_bytes | fn flow_memo_shadow_key_bytes(&mut self, f: P<FlowState>) | rust:flow.rs:571 | Checker
flow_memo_shadow_settle | fn flow_memo_shadow_settle(&mut self, f: P<FlowState>, memo: FrameMemo, entry_depth: u32, t: FlowType, taint: FrameTaint) | rust:flow.rs:519 | Checker
flow_type_of | fn flow_type_of(t: P<Type>) -> FlowType | rust:flow.rs:32 | -
flush_too_complex_reports | pub(crate) fn flush_too_complex_reports(&mut self) | rust:checker_13.rs:1488 | Checker
for_each_enclosing_class | pub(crate) fn for_each_enclosing_class(&mut self, node: P<Node>, callback: impl FnMut(&mut Checker, P<Node>) -> bool) -> bool | checker.go:12167 | Checker
for_each_export_and_property_of_module | pub fn for_each_export_and_property_of_module(&mut self, module_symbol: P<Symbol>, cb: impl FnMut(&mut Checker, P<Symbol>, &str)) | services.go:136 | Checker
for_each_mapped_type_property_key_type_and_index_signature_key_type | pub(crate) fn for_each_mapped_type_property_key_type_and_index_signature_key_type(&mut self, t: P<Type>, include: TypeFlags, strings_only: bool, cb: impl FnMut(&mut Checker, P<Type>)) | checker.go:23152 | Checker
for_each_property | pub(crate) fn for_each_property(&mut self, prop: P<Symbol>, callback: impl FnMut(&mut Checker, P<Symbol>) -> bool) -> bool | checker.go:12109 | Checker
for_each_property_worker | fn for_each_property_worker(&mut self, prop: P<Symbol>, callback: &mut dyn FnMut(&mut Checker, P<Symbol>) -> bool) -> bool | rust:checker_06.rs:1537 | Checker
for_each_type | pub(crate) fn for_each_type(c: &mut Checker, t: P<Type>, f: impl FnMut(&mut Checker, P<Type>)) | checker.go:26997 | -
for_each_yield_expression | pub(crate) fn for_each_yield_expression(body: P<Node>, visitor: impl FnMut(P<Node>) -> bool) -> bool | utilities.go:1264 | -
for_write | fn for_write(&self) -> Option<P<RefCell<FxHashMap<K, V>>>> | rust:types.rs:84 | GoMap
forget_scratch_keyed_caches | pub fn forget_scratch_keyed_caches(&mut self) | rust:checker_15.rs:2562 | Checker
fork | pub fn fork(base: &'static Checker) -> Box<Checker> | rust:checker.rs:1982 | Checker
fork | pub fn fork(&'static self) -> Self | rust:links.rs:470 | IdLinkStore
fork | pub fn fork(&'static self) -> Self | rust:links.rs:599 | InlineIdStore
fork | pub fn fork(&'static self) -> Self | rust:links.rs:240 | KeyedLinkStore
fork | pub fn fork(&'static self) -> Self | rust:links.rs:99 | LinkStore
fork | pub fn fork(&'static self) -> Self | rust:links.rs:694 | NodeLinkStore
fork | pub fn fork(&'static self) -> Self | rust:packedmap.rs:216 | StringLiteralTypes
fork | pub fn fork(&'static self) -> Self | rust:links.rs:745 | SymbolArenaLinkStore
fork | pub fn fork(&'static self) -> Self | rust:links.rs:302 | SymbolReferenceLinkStore
format_type_flags | pub fn format_type_flags(flags: TypeFlags) -> Vec<&'static str> | rust:types.rs:982 | -
format_union_types | pub(crate) fn format_union_types(&mut self, types: &[P<Type>], expanding_enum: bool) -> Vec<P<Type>> | printer.go:253 | Checker
free_type_list | pub(crate) fn free_type_list(&mut self, list: Vec<P<Type>>) | rust:checker_11.rs:2008 | Checker
fresh_type | pub fn fresh_type(&self) -> Option<P<Type>> | rust:types.rs:1995 | LiteralType
from_bits | const fn from_bits(bits: u32) -> Self | rust:checker.rs:649 | InferencePriority
from_one | pub fn from_one(key: K, value: V) -> Self | rust:packedmap.rs:65 | PackedMap
from_u128 | pub const fn from_u128(v: u128) -> CacheHashKey | rust:checker.rs:3018 | CacheHashKey
from_vec | pub fn from_vec(items: Vec<T>) -> Self | rust:checker.rs:563 | LazyVec
function_has_implicit_return | pub(crate) fn function_has_implicit_return(&mut self, fn_: P<Node>) -> bool | checker.go:20648 | Checker
function_or_constructor_checked | pub fn function_or_constructor_checked(&self) -> bool | rust:types.rs:534 | ValueSymbolLinks
generate_jsx_children | pub(crate) fn generate_jsx_children(node: P<Node>, get_invalid_text_diagnostic: InvalidTextDiagnosticFn) -> impl FnMut(&mut Checker) -> Option<JsxElaborationElement> + 'static + use<> | jsx.go:376 | Checker
get | pub fn get(&self, key: &K) -> Option<V> | rust:basedmap.rs:41 | Based
get | pub fn get(&self, key: &K) -> Option<&V> | rust:basedmap.rs:63 | Based
get | pub fn get(&self) -> usize | rust:types.rs:16 | CountCell
get | pub fn get<Q: ?Sized + Hash + Eq>(&self, key: &Q) -> Option<V> where K: std::borrow::Borrow<Q>, | rust:types.rs:99 | GoMap
get | pub fn get(&self, key: &K) -> Option<V> | rust:packedmap.rs:145 | GoPackedMap
get | pub fn get(&mut self, id: u64) -> P<V> | rust:links.rs:478 | IdLinkStore
get | pub fn get(&mut self, id: u64) -> &'static V | rust:links.rs:615 | InlineIdStore
get | pub fn get(&mut self, key: P<K>) -> P<V> | rust:links.rs:255 | KeyedLinkStore
get | pub fn get(&mut self, key: P<K>) -> P<V> | rust:links.rs:109 | LinkStore
get | pub fn get(&self) -> Option<P<TypeMapper>> | rust:mapper.rs:414 | MapperCell
get | pub fn get(&self, symbol: &P<Symbol>) -> Option<&P<Symbol>> | rust:merged_symbols.rs:31 | MergedSymbols
get | pub fn get(&mut self, node: P<Node>) -> &'static V | rust:links.rs:703 | NodeLinkStore
get | pub fn get(&self) -> ObjectFlags | rust:types.rs:1233 | ObjectFlagsCell
get | pub fn get(&self) -> Option<usize> | rust:types.rs:37 | OptionalCountCell
get | pub fn get(&self, key: &K) -> Option<V> | rust:packedmap.rs:72 | PackedMap
get | pub fn get(&self, type_arguments: &[P<Type>]) -> Option<P<Type>> | rust:types.rs:2280 | ReferenceInstantiations
get | pub fn get(&self, value: &str) -> Option<P<Type>> | rust:packedmap.rs:206 | StringLiteralTypes
get | pub fn get(&mut self, symbol: P<Symbol>) -> P<V> | rust:links.rs:753 | SymbolArenaLinkStore
get_access_stack | pub(crate) fn get_access_stack(ref_: P<Node>) -> Vec<P<Node>> | nodebuilderimpl.go:325 | -
get_accessed_property_name | pub fn get_accessed_property_name(&mut self, access: P<Node>) -> (std::borrow::Cow<'static, str>, bool) | flow.go:1727 | Checker
get_accessible_symbol_chain | pub fn get_accessible_symbol_chain(&mut self, symbol: P<Symbol>, enclosing_declaration: Option<P<Node>>, meaning: SymbolFlags, use_only_external_aliasing: bool) -> Vec<P<Symbol>> | symbolaccessibility.go:373 | Checker
get_accessible_symbol_chain_ex | pub(crate) fn get_accessible_symbol_chain_ex(&mut self, ctx: &accessibleSymbolChainContext) -> Vec<P<Symbol>> | symbolaccessibility.go:441 | Checker
get_accessible_symbol_chain_exported | pub fn get_accessible_symbol_chain_exported(&mut self, symbol: P<Symbol>, enclosing_declaration: Option<P<Node>>, meaning: SymbolFlags, use_only_external_aliasing: bool) -> Vec<P<Symbol>> | symbolaccessibility.go:382 | Checker
get_accessible_symbol_chain_from_symbol_table | pub(crate) fn get_accessible_symbol_chain_from_symbol_table(&mut self, ctx: &accessibleSymbolChainContext, t: Option<P<SymbolTable>>, table_id: symbolTableID, ignore_qualification: bool, is_local_name_lookup: bool) -> Vec<P<Symbol>> | symbolaccessibility.go:481 | Checker
get_accessor_this_parameter | pub(crate) fn get_accessor_this_parameter(accessor: P<Node>) -> Option<P<Node>> | checker.go:20272 | Checker
get_actual_type_variable | pub(crate) fn get_actual_type_variable(&mut self, t: P<Type>) -> Option<P<Type>> | checker.go:32060 | Checker
get_adjusted_node_for_error | pub(crate) fn get_adjusted_node_for_error(node: P<Node>) -> P<Node> | checker.go:14497 | -
get_adjusted_type_with_facts | pub(crate) fn get_adjusted_type_with_facts(&mut self, t: P<Type>, facts: TypeFacts) -> P<Type> | checker.go:31648 | Checker
get_alias_declaration_from_name | pub(crate) fn get_alias_declaration_from_name(node: P<Node>) -> Option<P<Node>> | utilities.go:206 | -
get_alias_for_symbol_in_container | pub(crate) fn get_alias_for_symbol_in_container(&mut self, container: P<Symbol>, symbol: P<Symbol>) -> Option<P<Symbol>> | symbolaccessibility.go:342 | Checker
get_alias_for_type_node | pub(crate) fn get_alias_for_type_node(&mut self, node: P<Node>) -> Option<P<TypeAlias>> | checker.go:24172 | Checker
get_alias_key | pub(crate) fn get_alias_key(alias: AliasArg<'_>) -> CacheHashKey | checker.go:17842 | -
get_alias_symbol_for_type_node | pub(crate) fn get_alias_symbol_for_type_node(&mut self, node: P<Node>) -> Option<P<Symbol>> | checker.go:24180 | Checker
get_alias_variances | pub(crate) fn get_alias_variances(&mut self, symbol: P<Symbol>) -> Vec<VarianceFlags> | relater.go:1325 | Checker
get_aliased_symbol | pub fn get_aliased_symbol(&mut self, symbol: P<Symbol>) -> P<Symbol> | checker.go:32664 | Checker
get_all_jsdoc_tags | pub(crate) fn get_all_jsdoc_tags(node: P<Node>) -> Vec<P<Node>> | jsdoc.go:86 | -
get_all_possible_properties_of_types | pub fn get_all_possible_properties_of_types(&mut self, types: &[P<Type>]) -> Vec<P<Symbol>> | services.go:210 | Checker
get_alternative_containing_modules | pub(crate) fn get_alternative_containing_modules(&mut self, symbol: P<Symbol>, enclosing_declaration: Option<P<Node>>) -> Vec<P<Symbol>> | symbolaccessibility.go:168 | Checker
get_ambient_modules | pub fn get_ambient_modules(&mut self) -> Vec<P<Symbol>> | checker.go:15859 | Checker
get_annotated_accessor_this_parameter | pub(crate) fn get_annotated_accessor_this_parameter(accessor: P<Node>) -> Option<P<Symbol>> | checker.go:20264 | Checker
get_annotated_accessor_type | pub(crate) fn get_annotated_accessor_type(&mut self, accessor: Option<P<Node>>) -> Option<P<Type>> | checker.go:20439 | Checker
get_annotated_accessor_type_node | pub(crate) fn get_annotated_accessor_type_node(accessor: Option<P<Node>>) -> Option<P<Node>> | checker.go:20447 | Checker
get_any_import_syntax | pub(crate) fn get_any_import_syntax(node: P<Node>) -> Option<P<Node>> | utilities.go:1657 | -
get_any_type | pub fn get_any_type(&self) -> P<Type> | exports.go:32 | Checker
get_apparent_mapped_type_keys | pub(crate) fn get_apparent_mapped_type_keys(&mut self, name_type: P<Type>, target_type: P<Type>) -> P<Type> | checker.go:23143 | Checker
get_apparent_properties | pub fn get_apparent_properties(&mut self, t: P<Type>) -> Vec<P<Symbol>> | services.go:269 | Checker
get_apparent_type | pub fn get_apparent_type(&mut self, t: P<Type>) -> P<Type> | checker.go:22091 | Checker
get_apparent_type_exported | pub fn get_apparent_type_exported(&mut self, t: P<Type>) -> P<Type> | exports.go:308 | Checker
get_apparent_type_of_contextual_type | pub fn get_apparent_type_of_contextual_type(&mut self, node: P<Node>, context_flags: ContextFlags) -> Option<P<Type>> | checker.go:31175 | Checker
get_apparent_type_of_intersection_type | pub(crate) fn get_apparent_type_of_intersection_type(&mut self, t: P<Type>, this_argument: P<Type>) -> P<Type> | checker.go:22158 | Checker
get_apparent_type_of_mapped_type | pub(crate) fn get_apparent_type_of_mapped_type(&mut self, t: P<Type>) -> P<Type> | checker.go:22126 | Checker
get_apparent_type_worker | fn get_apparent_type_worker(&mut self, t: P<Type>) -> P<Type> | rust:checker_11.rs:454 | Checker
get_applicable_index_info | pub(crate) fn get_applicable_index_info(&mut self, t: P<Type>, key_type: P<Type>) -> Option<P<IndexInfo>> | checker.go:19352 | Checker
get_applicable_index_info_for_name | pub(crate) fn get_applicable_index_info_for_name(&mut self, t: P<Type>, name: &str) -> Option<P<IndexInfo>> | checker.go:19356 | Checker
get_applicable_index_infos | pub(crate) fn get_applicable_index_infos(&mut self, t: P<Type>, key_type: P<Type>) -> Vec<P<IndexInfo>> | checker.go:32575 | Checker
get_applicable_index_symbol | pub(crate) fn get_applicable_index_symbol(&mut self, t: P<Type>, key_type: P<Type>) -> Option<P<Symbol>> | checker.go:32579 | Checker
get_argument_arity_error | pub(crate) fn get_argument_arity_error(&mut self, node: P<Node>, signatures: &[P<Signature>], args: &[P<Node>], head_message: Option<&'static Message>) -> P<Diagnostic> | checker.go:9897 | Checker
get_arguments_symbol | pub fn get_arguments_symbol(&self) -> P<Symbol> | exports.go:72 | Checker
get_array_element_type_node | pub(crate) fn get_array_element_type_node(node: P<Node>) -> Option<P<Node>> | checker.go:24655 | Checker
get_array_member_call_signatures | pub(crate) fn get_array_member_call_signatures(&mut self, t: P<Type>) -> Vec<P<Signature>> | checker.go:21412 | Checker
get_array_or_tuple_target_type | pub(crate) fn get_array_or_tuple_target_type(&mut self, node: P<Node>) -> P<Type> | checker.go:24618 | Checker
get_assigned_type | pub(crate) fn get_assigned_type(&mut self, node: P<Node>) -> P<Type> | flow.go:2288 | Checker
get_assigned_type_of_array_literal_element | pub(crate) fn get_assigned_type_of_array_literal_element(&mut self, node: P<Node>, element: P<Node>) -> P<Type> | flow.go:2323 | Checker
get_assigned_type_of_binary_expression | pub(crate) fn get_assigned_type_of_binary_expression(&mut self, node: P<Node>) -> P<Type> | flow.go:2314 | Checker
get_assigned_type_of_property_assignment | pub(crate) fn get_assigned_type_of_property_assignment(&mut self, node: P<Node>) -> P<Type> | flow.go:2361 | Checker
get_assigned_type_of_shorthand_property_assignment | pub(crate) fn get_assigned_type_of_shorthand_property_assignment(&mut self, node: P<Node>) -> P<Type> | flow.go:2380 | Checker
get_assigned_type_of_spread_expression | pub(crate) fn get_assigned_type_of_spread_expression(&mut self, node: P<Node>) -> P<Type> | flow.go:2349 | Checker
get_assignment_declaration_initializer_type | pub(crate) fn get_assignment_declaration_initializer_type(&mut self, node: P<Node>) -> Option<P<Type>> | checker.go:18456 | Checker
get_assignment_reduced_type | pub fn get_assignment_reduced_type(&mut self, declared_type: P<Type>, assigned_type: P<Type>) -> P<Type> | flow.go:2399 | Checker
get_assignment_reduced_type_worker | pub(crate) fn get_assignment_reduced_type_worker(&mut self, declared_type: P<Type>, assigned_type: P<Type>) -> P<Type> | flow.go:2415 | Checker
get_assignment_target_kind | pub(crate) fn get_assignment_target_kind(node: P<Node>) -> AssignmentKind | utilities.go:89 | -
get_async_from_sync_iteration_types | pub(crate) fn get_async_from_sync_iteration_types(&mut self, iteration_types: IterationTypes, error_node: Option<P<Node>>) -> IterationTypes | checker.go:6606 | Checker
get_augmented_properties_of_type | pub(crate) fn get_augmented_properties_of_type(&mut self, t: P<Type>) -> Vec<P<Symbol>> | services.go:273 | Checker
get_awaited_type | pub fn get_awaited_type(&mut self, t: P<Type>) -> Option<P<Type>> | checker.go:31742 | Checker
get_awaited_type_ex | pub(crate) fn get_awaited_type_ex(&mut self, t: P<Type>, error_node: Option<P<Node>>, diagnostic_message: Option<&'static Message>, args: &[&dyn Display]) -> Option<P<Type>> | checker.go:31746 | Checker
get_awaited_type_exported | pub fn get_awaited_type_exported(&mut self, t: P<Type>) -> Option<P<Type>> | exports.go:272 | Checker
get_awaited_type_no_alias | pub(crate) fn get_awaited_type_no_alias(&mut self, t: P<Type>) -> Option<P<Type>> | checker.go:31755 | Checker
get_awaited_type_no_alias_ex | pub(crate) fn get_awaited_type_no_alias_ex(&mut self, t: P<Type>, error_node: Option<P<Node>>, diagnostic_message: Option<&'static Message>, args: &[&dyn Display]) -> Option<P<Type>> | checker.go:31759 | Checker
get_awaited_type_of_promise | pub(crate) fn get_awaited_type_of_promise(&mut self, t: P<Type>) -> Option<P<Type>> | checker.go:31947 | Checker
get_awaited_type_of_promise_ex | pub(crate) fn get_awaited_type_of_promise_ex(&mut self, t: P<Type>, error_node: Option<P<Node>>, diagnostic_message: Option<&'static Message>, args: &[&dyn Display]) -> Option<P<Type>> | checker.go:31951 | Checker
get_base_constraint_of_type | pub fn get_base_constraint_of_type(&mut self, t: P<Type>) -> Option<P<Type>> | checker.go:27906 | Checker
get_base_constraint_of_type_exported | pub fn get_base_constraint_of_type_exported(&mut self, t: P<Type>) -> Option<P<Type>> | exports.go:211 | Checker
get_base_constraint_or_type | pub(crate) fn get_base_constraint_or_type(&mut self, t: P<Type>) -> P<Type> | checker.go:27898 | Checker
get_base_constructor_type_of_class | pub fn get_base_constructor_type_of_class(&mut self, t: P<Type>) -> P<Type> | checker.go:17281 | Checker
get_base_constructor_type_of_class_exported | pub fn get_base_constructor_type_of_class_exported(&mut self, t: P<Type>) -> P<Type> | exports.go:322 | Checker
get_base_signature | pub(crate) fn get_base_signature(&mut self, signature: P<Signature>) -> P<Signature> | checker.go:19779 | Checker
get_base_type_node_of_class | pub(crate) fn get_base_type_node_of_class(t: P<Type>) -> Option<P<Node>> | checker.go:19608 | -
get_base_type_of_enum_like_type | pub(crate) fn get_base_type_of_enum_like_type(&mut self, t: P<Type>) -> P<Type> | checker.go:25940 | Checker
get_base_type_of_literal_type | pub fn get_base_type_of_literal_type(&mut self, t: P<Type>) -> P<Type> | checker.go:25904 | Checker
get_base_type_of_literal_type_exported | pub fn get_base_type_of_literal_type_exported(&mut self, t: P<Type>) -> P<Type> | exports.go:60 | Checker
get_base_type_of_literal_type_for_comparison | pub(crate) fn get_base_type_of_literal_type_for_comparison(&mut self, t: P<Type>) -> P<Type> | checker.go:25924 | Checker
get_base_type_of_literal_type_union | pub(crate) fn get_base_type_of_literal_type_union(&mut self, t: P<Type>) -> P<Type> | checker.go:25947 | Checker
get_base_type_variable_of_class | pub(crate) fn get_base_type_variable_of_class(&mut self, symbol: P<Symbol>) -> Option<P<Type>> | checker.go:17260 | Checker
get_base_types | pub fn get_base_types(&mut self, t: P<Type>) -> &'static [P<Type>] | checker.go:19508 | Checker
get_base_types_exported | pub fn get_base_types_exported(&mut self, t: P<Type>) -> &'static [P<Type>] | exports.go:304 | Checker
get_base_types_if_unrelated | pub(crate) fn get_base_types_if_unrelated(&mut self, left_type: P<Type>, right_type: P<Type>, is_related: impl FnMut(&mut Checker, P<Type>, P<Type>) -> bool) -> (P<Type>, P<Type>) | checker.go:12953 | Checker
get_best_match_indexed_access_type_or_undefined | pub(crate) fn get_best_match_indexed_access_type_or_undefined(&mut self, source: P<Type>, target: P<Type>, name_type: P<Type>) -> Option<P<Type>> | relater.go:618 | Checker
get_best_matching_type | pub(crate) fn get_best_matching_type(&mut self, source: P<Type>, target: P<Type>, is_related_to: impl FnMut(&mut Checker, P<Type>, P<Type>) -> Ternary) -> Option<P<Type>> | relater.go:872 | Checker
get_big_int_literal_type | pub(crate) fn get_big_int_literal_type(&mut self, value: PseudoBigInt) -> P<Type> | checker.go:25801 | Checker
get_big_int_literal_value | pub(crate) fn get_big_int_literal_value(t: P<Type>) -> PseudoBigInt | checker.go:25824 | -
get_big_int_type | pub fn get_big_int_type(&self) -> P<Type> | exports.go:48 | Checker
get_binding_element_property_name | pub(crate) fn get_binding_element_property_name(node: P<Node>) -> Option<P<Node>> | utilities.go:1124 | -
get_binding_element_type_from_parent_type | pub(crate) fn get_binding_element_type_from_parent_type(&mut self, declaration: P<Node>, parent_type: P<Type>, no_tuple_bounds_check: bool) -> P<Type> | checker.go:18047 | Checker
get_boolean_literal_value | pub(crate) fn get_boolean_literal_value(t: P<Type>) -> bool | checker.go:25828 | -
get_boolean_type | pub fn get_boolean_type(&self) -> P<Type> | exports.go:16 | Checker
get_branch_label_antecedents | pub(crate) fn get_branch_label_antecedents(flow: P<FlowNode>, reduce_labels: &[P<ast::FlowReduceLabelData>]) -> Option<P<FlowList>> | flow.go:208 | -
get_builtin_iterator_return_type | pub(crate) fn get_builtin_iterator_return_type(&self) -> P<Type> | checker.go:6570 | Checker
get_call_signatures | pub fn get_call_signatures(&mut self, t: P<Type>) -> &'static [P<Signature>] | services.go:261 | Checker
get_candidate_discriminant_property_access | pub(crate) fn get_candidate_discriminant_property_access(&mut self, f: P<FlowState>, expr: P<Node>) -> Option<P<Node>> | flow.go:1457 | Checker
get_candidate_for_overload_failure | pub(crate) fn get_candidate_for_overload_failure(&mut self, node: P<Node>, candidates: &mut [P<Signature>], args: &[P<Node>], has_candidates_out_array: bool, check_mode: CheckMode) -> P<Signature> | checker.go:9690 | Checker
get_candidate_list_for_symbol | pub(crate) fn get_candidate_list_for_symbol(&mut self, ctx: &accessibleSymbolChainContext, symbol_from_symbol_table: P<Symbol>, resolved_imported_symbol: P<Symbol>, ignore_qualification: bool) -> Vec<P<Symbol>> | symbolaccessibility.go:620 | Checker
get_candidate_signatures_for_string_literal_completions | pub fn get_candidate_signatures_for_string_literal_completions(&mut self, call: P<Node>, editing_argument: P<Node>) -> Vec<P<Signature>> | services.go:911 | Checker
get_candidate_variable_declaration_initializer | pub(crate) fn get_candidate_variable_declaration_initializer(node: P<Node>) -> Option<P<Node>> | flow.go:1496 | -
get_cannot_find_name_diagnostic_for_name | pub(crate) fn get_cannot_find_name_diagnostic_for_name(&self, node: P<Node>) -> &'static Message | checker.go:14150 | Checker
get_cannot_resolve_module_name_error_for_specific_module | pub(crate) fn get_cannot_resolve_module_name_error_for_specific_module(&self, module_name: P<Node>) -> Option<&'static Message> | checker.go:15353 | Checker
get_canonical_signature | pub(crate) fn get_canonical_signature(&mut self, signature: P<Signature>) -> P<Signature> | checker.go:19750 | Checker
get_chain_message | pub(crate) fn get_chain_message(&self, _c: &mut Checker, index: usize) -> Option<&'static Message> | relater.go:4934 | Relater
get_child_context | pub(crate) fn get_child_context(w: P<WideningContext>, property_name: &str) -> P<WideningContext> | checker.go:18794 | WideningContext
get_circular_type_names | pub(crate) fn get_circular_type_names(&mut self) -> Vec<String> | checker.go:22551 | Checker
get_class_element_property_key_type | pub(crate) fn get_class_element_property_key_type(&mut self, element: P<Node>) -> P<Type> | checker.go:31025 | Checker
get_class_expression_name_table | pub(crate) fn get_class_expression_name_table(&mut self, location: P<Node>) -> Option<P<SymbolTable>> | symbolaccessibility.go:810 | Checker
get_class_member_decorator_context_override_type | pub(crate) fn get_class_member_decorator_context_override_type(&mut self, name_type: P<Type>, is_private: bool, is_static: bool) -> P<Type> | checker.go:30922 | Checker
get_class_or_interface_declarations_of_symbol | pub(crate) fn get_class_or_interface_declarations_of_symbol(symbol: P<Symbol>) -> Vec<P<Node>> | checker.go:4495 | Checker
get_class_or_interface_like_declaration | pub(crate) fn get_class_or_interface_like_declaration(symbol: P<Symbol>) -> Option<P<Node>> | checker.go:24205 | Checker
get_combined_mapped_type_optionality | pub(crate) fn get_combined_mapped_type_optionality(&mut self, t: P<Type>) -> std::cmp::Ordering | checker.go:29510 | Checker
get_combined_modifier_flags_cached | pub(crate) fn get_combined_modifier_flags_cached(&mut self, node: P<Node>) -> ModifierFlags | checker.go:19081 | Checker
get_combined_node_flags_cached | pub(crate) fn get_combined_node_flags_cached(&mut self, node: P<Node>) -> NodeFlags | checker.go:19032 | Checker
get_combined_type_flags | pub(crate) fn get_combined_type_flags(types: &[P<Type>]) -> TypeFlags | inference.go:1590 | Checker
get_common_subtype | pub(crate) fn get_common_subtype(&mut self, types: &[P<Type>]) -> Option<P<Type>> | inference.go:1580 | Checker
get_common_supertype | pub(crate) fn get_common_supertype(&mut self, types: &[P<Type>]) -> Option<P<Type>> | inference.go:1531 | Checker
get_conditional_flow_type_of_type | pub(crate) fn get_conditional_flow_type_of_type(&mut self, t: P<Type>, node: Option<P<Node>>) -> P<Type> | checker.go:25422 | Checker
get_conditional_type | pub(crate) fn get_conditional_type(&mut self, root: P<ConditionalRoot>, mapper: Option<P<TypeMapper>>, for_constraint: bool, alias: Option<P<TypeAlias>>) -> P<Type> | checker.go:24770 | Checker
get_conditional_type_instantiation | pub(crate) fn get_conditional_type_instantiation(&mut self, t: P<Type>, mapper: P<TypeMapper>, for_constraint: bool, alias: Option<P<TypeAlias>>) -> P<Type> | checker.go:22910 | Checker
get_conditional_type_instantiation_ex | pub(crate) fn get_conditional_type_instantiation_ex(&mut self, t: P<Type>, m1: Option<P<TypeMapper>>, mapper: P<TypeMapper>, for_constraint: bool, alias: Option<P<TypeAlias>>) -> P<Type> | rust:checker_11.rs:1571 | Checker
get_conditional_type_key | pub(crate) fn get_conditional_type_key(type_arguments: &[P<Type>], alias: Option<P<TypeAlias>>, for_constraint: bool) -> CacheHashKey | checker.go:17943 | -
get_conditional_type_key_hashed | fn get_conditional_type_key_hashed(type_arguments: &[P<Type>], alias: Option<P<TypeAlias>>, for_constraint: bool) -> CacheHashKey | rust:checker_09.rs:726 | -
get_conditional_type_worker | fn get_conditional_type_worker(&mut self, root: P<ConditionalRoot>, mapper: Option<P<TypeMapper>>, for_constraint: bool, alias: Option<P<TypeAlias>>) -> P<Type> | rust:checker_12.rs:1031 | Checker
get_constant_value | pub fn get_constant_value(&mut self, node: P<Node>) -> Option<LiteralValue> | services.go:870 | Checker
get_constant_value | pub fn get_constant_value(&self, c: &mut Checker, node: P<Node>) -> Option<LiteralValue> | emitresolver.go:1158 | EmitResolver
get_constituent_count | pub(crate) fn get_constituent_count(t: P<Type>) -> usize | checker.go:26922 | -
get_constituent_count_of_types | pub(crate) fn get_constituent_count_of_types(types: &[P<Type>]) -> usize | checker.go:26932 | -
get_constituent_property | pub(crate) fn get_constituent_property(&mut self, object_type: P<Type>, property_name: &str) -> Option<P<Symbol>> | checker.go:8429 | Checker
get_constituent_type_for_key_type | pub(crate) fn get_constituent_type_for_key_type(&mut self, t: P<Type>, key_type: P<Type>) -> Option<P<Type>> | relater.go:1124 | Checker
get_constraint_declaration | pub(crate) fn get_constraint_declaration(t: P<Type>) -> Option<P<Node>> | checker.go:29602 | Checker
get_constraint_declaration_for_mapped_type | pub(crate) fn get_constraint_declaration_for_mapped_type(t: P<Type>) -> Option<P<Node>> | checker.go:23139 | Checker
get_constraint_from_conditional_type | pub(crate) fn get_constraint_from_conditional_type(&mut self, t: P<Type>) -> P<Type> | checker.go:17579 | Checker
get_constraint_from_indexed_access | pub(crate) fn get_constraint_from_indexed_access(&mut self, t: P<Type>) -> Option<P<Type>> | checker.go:17551 | Checker
get_constraint_from_type_parameter | pub(crate) fn get_constraint_from_type_parameter(&mut self, t: P<Type>) -> Option<P<Type>> | checker.go:17395 | Checker
get_constraint_of_conditional_type | pub(crate) fn get_constraint_of_conditional_type(&mut self, t: P<Type>) -> Option<P<Type>> | checker.go:17572 | Checker
get_constraint_of_distributive_conditional_type | pub(crate) fn get_constraint_of_distributive_conditional_type(&mut self, t: P<Type>) -> Option<P<Type>> | checker.go:17608 | Checker
get_constraint_of_indexed_access | pub(crate) fn get_constraint_of_indexed_access(&mut self, t: P<Type>) -> Option<P<Type>> | checker.go:17544 | Checker
get_constraint_of_type | pub(crate) fn get_constraint_of_type(&mut self, t: P<Type>) -> Option<P<Type>> | checker.go:17371 | Checker
get_constraint_of_type_parameter | pub fn get_constraint_of_type_parameter(&mut self, type_parameter: P<Type>) -> Option<P<Type>> | checker.go:17383 | Checker
get_constraint_of_type_parameter_exported | pub fn get_constraint_of_type_parameter_exported(&mut self, type_parameter: P<Type>) -> Option<P<Type>> | exports.go:191 | Checker
get_constraint_or_unknown_from_type_parameter | pub(crate) fn get_constraint_or_unknown_from_type_parameter(&mut self, t: P<Type>) -> P<Type> | checker.go:17433 | Checker
get_constraint_type_from_mapped_type | pub(crate) fn get_constraint_type_from_mapped_type(&mut self, t: P<Type>) -> P<Type> | checker.go:23103 | Checker
get_construct_signatures | pub fn get_construct_signatures(&mut self, t: P<Type>) -> &'static [P<Signature>] | services.go:265 | Checker
get_constructor_accessibility_error | pub(crate) fn get_constructor_accessibility_error(&mut self, node: P<Node>, signatures: &[P<Signature>], modifiers_mask: ModifierFlags) -> Option<P<constructorAccessibilityError>> | checker.go:8834 | Checker
get_constructors_for_type_arguments | pub(crate) fn get_constructors_for_type_arguments(&mut self, t: P<Type>, type_argument_nodes: &[P<Node>], _location: P<Node>) -> Vec<P<Signature>> | checker.go:19627 | Checker
get_containers_of_symbol | pub(crate) fn get_containers_of_symbol(&mut self, symbol: P<Symbol>, enclosing_declaration: Option<P<Node>>, meaning: SymbolFlags) -> Vec<P<Symbol>> | symbolaccessibility.go:280 | Checker
get_containing_class_excluding_class_decorators | pub(crate) fn get_containing_class_excluding_class_decorators(node: P<Node>) -> Option<P<Node>> | utilities.go:1037 | -
get_containing_function_or_class_static_block | pub(crate) fn get_containing_function_or_class_static_block(node: P<Node>) -> Option<P<Node>> | utilities.go:908 | -
get_containing_object_literal | pub(crate) fn get_containing_object_literal(f: P<Node>) -> Option<P<Node>> | utilities.go:1163 | -
get_containing_qualified_name_node | pub(crate) fn get_containing_qualified_name_node(node: P<Node>) -> P<Node> | utilities.go:221 | -
get_context_free_type_of_expression | pub fn get_context_free_type_of_expression(&mut self, node: P<Node>) -> P<Type> | checker.go:7714 | Checker
get_context_node | pub(crate) fn get_context_node(node: P<Node>) -> Option<P<Node>> | checker.go:7677 | Checker
get_contextual_call_signature | pub(crate) fn get_contextual_call_signature(&mut self, t: P<Type>, node: P<Node>) -> Option<P<Signature>> | checker.go:10502 | Checker
get_contextual_import_attribute_type | pub(crate) fn get_contextual_import_attribute_type(&mut self, node: P<Node>) -> Option<P<Type>> | checker.go:30526 | Checker
get_contextual_iteration_type | pub(crate) fn get_contextual_iteration_type(&mut self, kind: IterationTypeKind, function_decl: P<Node>) -> Option<P<Type>> | checker.go:30145 | Checker
get_contextual_jsx_element_attributes_type | pub(crate) fn get_contextual_jsx_element_attributes_type(&mut self, node: P<Node>, context_flags: ContextFlags) -> Option<P<Type>> | jsx.go:229 | Checker
get_contextual_return_type | pub(crate) fn get_contextual_return_type(&mut self, function_decl: P<Node>, context_flags: ContextFlags) -> Option<P<Type>> | checker.go:30154 | Checker
get_contextual_signature | pub(crate) fn get_contextual_signature(&mut self, node: P<Node>) -> Option<P<Signature>> | checker.go:10461 | Checker
get_contextual_signature_for_function_like_declaration | pub(crate) fn get_contextual_signature_for_function_like_declaration(&mut self, node: P<Node>) -> Option<P<Signature>> | checker.go:30200 | Checker
get_contextual_this_parameter_type | pub(crate) fn get_contextual_this_parameter_type(&mut self, fn_: P<Node>) -> Option<P<Type>> | checker.go:12224 | Checker
get_contextual_type | pub fn get_contextual_type(&mut self, node: P<Node>, context_flags: ContextFlags) -> Option<P<Type>> | checker.go:29832 | Checker
get_contextual_type_exported | pub fn get_contextual_type_exported(&mut self, node: P<Node>, context_flags: ContextFlags) -> Option<P<Type>> | services.go:327 | Checker
get_contextual_type_for_argument | pub(crate) fn get_contextual_type_for_argument(&mut self, call_target: P<Node>, arg: P<Node>) -> Option<P<Type>> | checker.go:30251 | Checker
get_contextual_type_for_argument_at_index | pub fn get_contextual_type_for_argument_at_index(&mut self, call_target: P<Node>, arg_index: usize) -> P<Type> | checker.go:30261 | Checker
get_contextual_type_for_argument_at_index_exported | pub fn get_contextual_type_for_argument_at_index_exported(&mut self, node: P<Node>, arg_index: usize) -> P<Type> | exports.go:268 | Checker
get_contextual_type_for_array_literal_at_position | pub fn get_contextual_type_for_array_literal_at_position(&mut self, contextual_array_type: Option<P<Type>>, array_literal: P<Node>, position: u32) -> Option<P<Type>> | services.go:953 | Checker
get_contextual_type_for_assignment_expression | pub(crate) fn get_contextual_type_for_assignment_expression(&mut self, binary: P<Node>) -> Option<P<Type>> | checker.go:30332 | Checker
get_contextual_type_for_await_operand | pub(crate) fn get_contextual_type_for_await_operand(&mut self, node: P<Node>, context_flags: ContextFlags) -> Option<P<Type>> | checker.go:30239 | Checker
get_contextual_type_for_binary_operand | pub(crate) fn get_contextual_type_for_binary_operand(&mut self, node: P<Node>, context_flags: ContextFlags) -> Option<P<Type>> | checker.go:30298 | Checker
get_contextual_type_for_binding_element | pub(crate) fn get_contextual_type_for_binding_element(&mut self, declaration: P<Node>, context_flags: ContextFlags) -> Option<P<Type>> | checker.go:30072 | Checker
get_contextual_type_for_child_jsx_expression | pub(crate) fn get_contextual_type_for_child_jsx_expression(&mut self, node: P<Node>, child: P<Node>, context_flags: ContextFlags) -> Option<P<Type>> | jsx.go:242 | Checker
get_contextual_type_for_conditional_operand | pub(crate) fn get_contextual_type_for_conditional_operand(&mut self, node: P<Node>, context_flags: ContextFlags) -> Option<P<Type>> | checker.go:30511 | Checker
get_contextual_type_for_decorator | pub(crate) fn get_contextual_type_for_decorator(&mut self, decorator: P<Node>) -> Option<P<Type>> | checker.go:30290 | Checker
get_contextual_type_for_element_expression | pub(crate) fn get_contextual_type_for_element_expression(&mut self, t: Option<P<Type>>, index: usize, length: Option<usize>, first_spread_index: Option<usize>, last_spread_index: Option<usize>) -> Option<P<Type>> | checker.go:30461 | Checker
get_contextual_type_for_initializer_expression | pub(crate) fn get_contextual_type_for_initializer_expression(&mut self, node: P<Node>, context_flags: ContextFlags) -> Option<P<Type>> | checker.go:29912 | Checker
get_contextual_type_for_jsx_attribute | pub(crate) fn get_contextual_type_for_jsx_attribute(&mut self, attribute: P<Node>, context_flags: ContextFlags) -> Option<P<Type>> | jsx.go:215 | Checker
get_contextual_type_for_jsx_attribute_exported | pub fn get_contextual_type_for_jsx_attribute_exported(&mut self, attribute: P<Node>) -> Option<P<Type>> | services.go:866 | Checker
get_contextual_type_for_jsx_expression | pub(crate) fn get_contextual_type_for_jsx_expression(&mut self, node: P<Node>, context_flags: ContextFlags) -> Option<P<Type>> | jsx.go:205 | Checker
get_contextual_type_for_object_literal_element | pub fn get_contextual_type_for_object_literal_element(&mut self, element: P<Node>, context_flags: ContextFlags) -> Option<P<Type>> | checker.go:30409 | Checker
get_contextual_type_for_object_literal_element_exported | pub fn get_contextual_type_for_object_literal_element_exported(&mut self, element: P<Node>, context_flags: ContextFlags) -> Option<P<Type>> | exports.go:247 | Checker
get_contextual_type_for_object_literal_method | pub(crate) fn get_contextual_type_for_object_literal_method(&mut self, node: P<Node>, context_flags: ContextFlags) -> Option<P<Type>> | checker.go:30453 | Checker
get_contextual_type_for_return_expression | pub(crate) fn get_contextual_type_for_return_expression(&mut self, node: P<Node>, context_flags: ContextFlags) -> Option<P<Type>> | checker.go:30110 | Checker
get_contextual_type_for_static_property_declaration | pub(crate) fn get_contextual_type_for_static_property_declaration(&mut self, declaration: P<Node>, context_flags: ContextFlags) -> Option<P<Type>> | checker.go:30101 | Checker
get_contextual_type_for_substitution_expression | pub(crate) fn get_contextual_type_for_substitution_expression(&mut self, template: P<Node>, substitution_expression: P<Node>) -> Option<P<Type>> | checker.go:30519 | Checker
get_contextual_type_for_variable_like_declaration | pub(crate) fn get_contextual_type_for_variable_like_declaration(&mut self, declaration: P<Node>, context_flags: ContextFlags) -> Option<P<Type>> | checker.go:29927 | Checker
get_contextual_type_for_yield_operand | pub(crate) fn get_contextual_type_for_yield_operand(&mut self, node: P<Node>, context_flags: ContextFlags) -> Option<P<Type>> | checker.go:30208 | Checker
get_contextually_typed_parameter_type | pub(crate) fn get_contextually_typed_parameter_type(&mut self, parameter: P<Node>) -> Option<P<Type>> | checker.go:29947 | Checker
get_contravariant_inference | pub(crate) fn get_contravariant_inference(&mut self, inference: P<InferenceInfo>) -> Option<P<Type>> | inference.go:1463 | Checker
get_control_flow_container | pub(crate) fn get_control_flow_container(node: P<Node>) -> Option<P<Node>> | checker.go:11639 | Checker
get_covariant_inference | pub(crate) fn get_covariant_inference(&mut self, inference: P<InferenceInfo>, signature: P<Signature>) -> P<Type> | inference.go:1434 | Checker
get_cross_product_intersections | pub(crate) fn get_cross_product_intersections(&mut self, types: &[P<Type>], flags: IntersectionFlags) -> Vec<P<Type>> | checker.go:26900 | Checker
get_cross_product_union_size | pub(crate) fn get_cross_product_union_size(types: &[P<Type>]) -> usize | checker.go:27130 | Checker
get_declaration_modifier_flags_from_symbol | pub fn get_declaration_modifier_flags_from_symbol(s: P<Symbol>) -> ModifierFlags | utilities.go:757 | -
get_declaration_modifier_flags_from_symbol_ex | pub(crate) fn get_declaration_modifier_flags_from_symbol_ex(s: P<Symbol>, is_write: bool) -> ModifierFlags | utilities.go:761 | -
get_declaration_modifier_flags_from_symbol_exported | pub fn get_declaration_modifier_flags_from_symbol_exported(s: P<Symbol>) -> ModifierFlags | exports.go:167 | -
get_declaration_node_flags_from_symbol | pub(crate) fn get_declaration_node_flags_from_symbol(&mut self, s: P<Symbol>) -> NodeFlags | checker.go:19025 | Checker
get_declaration_non_public_flags_from_symbol | pub(crate) fn get_declaration_non_public_flags_from_symbol(s: P<Symbol>) -> ModifierFlags | rust:utilities.rs:1133 | -
get_declaration_of_alias_symbol | pub fn get_declaration_of_alias_symbol(symbol: P<Symbol>) -> Option<P<Node>> | checker.go:16720 | Checker
get_declaration_spaces | pub(crate) fn get_declaration_spaces(&mut self, node: P<Node>) -> DeclarationSpaces | checker.go:7133 | Checker
get_declarations_of_kind | pub(crate) fn get_declarations_of_kind(symbol: P<Symbol>, kind: Kind) -> Vec<P<Node>> | utilities.go:1304 | -
get_declared_type_of_alias | pub(crate) fn get_declared_type_of_alias(&mut self, symbol: P<Symbol>) -> P<Type> | checker.go:24564 | Checker
get_declared_type_of_class_or_interface | pub(crate) fn get_declared_type_of_class_or_interface(&mut self, symbol: P<Symbol>) -> P<Type> | checker.go:17643 | Checker
get_declared_type_of_enum | pub(crate) fn get_declared_type_of_enum(&mut self, symbol: P<Symbol>) -> P<Type> | checker.go:24345 | Checker
get_declared_type_of_enum_member | pub(crate) fn get_declared_type_of_enum_member(&mut self, symbol: P<Symbol>) -> P<Type> | checker.go:24397 | Checker
get_declared_type_of_symbol | pub fn get_declared_type_of_symbol(&mut self, symbol: P<Symbol>) -> P<Type> | checker.go:24131 | Checker
get_declared_type_of_symbol_exported | pub fn get_declared_type_of_symbol_exported(&mut self, symbol: P<Symbol>) -> P<Type> | exports.go:179 | Checker
get_declared_type_of_type_alias | pub(crate) fn get_declared_type_of_type_alias(&mut self, symbol: P<Symbol>) -> P<Type> | checker.go:24307 | Checker
get_declared_type_of_type_parameter | pub(crate) fn get_declared_type_of_type_parameter(&mut self, symbol: P<Symbol>) -> P<Type> | checker.go:24299 | Checker
get_declaring_class | pub(crate) fn get_declaring_class(&mut self, prop: P<Symbol>) -> Option<P<Type>> | checker.go:12123 | Checker
get_declaring_constructor | pub(crate) fn get_declaring_constructor(symbol: P<Symbol>) -> Option<P<Node>> | checker.go:27815 | Checker
get_decorator_argument_count | pub(crate) fn get_decorator_argument_count(&mut self, node: P<Node>, signature: P<Signature>) -> usize | checker.go:9375 | Checker
get_decorator_call_signature | pub(crate) fn get_decorator_call_signature(&mut self, decorator: P<Node>) -> Option<P<Signature>> | checker.go:30644 | Checker
get_default_constraint_of_conditional_type | pub(crate) fn get_default_constraint_of_conditional_type(&mut self, t: P<Type>) -> P<Type> | checker.go:17587 | Checker
get_default_construct_signatures | pub(crate) fn get_default_construct_signatures(&mut self, class_type: P<Type>) -> Vec<P<Signature>> | checker.go:21198 | Checker
get_default_from_type_parameter | pub(crate) fn get_default_from_type_parameter(&mut self, t: P<Type>) -> Option<P<Type>> | checker.go:22392 | Checker
get_default_from_type_parameter_exported | pub fn get_default_from_type_parameter_exported(&mut self, type_parameter: P<Type>) -> Option<P<Type>> | exports.go:203 | Checker
get_default_or_unknown_from_type_parameter | pub(crate) fn get_default_or_unknown_from_type_parameter(&mut self, t: P<Type>) -> P<Type> | checker.go:22440 | Checker
get_default_type_argument_type | pub(crate) fn get_default_type_argument_type(&self, is_in_java_script_file: bool) -> P<Type> | checker.go:22382 | Checker
get_definitely_falsy_part_of_type | pub(crate) fn get_definitely_falsy_part_of_type(&self, t: P<Type>) -> P<Type> | checker.go:29584 | Checker
get_deprecated_suggestion_node | pub(crate) fn get_deprecated_suggestion_node(node: P<Node>) -> Option<P<Node>> | checker.go:3081 | Checker
get_destructuring_property_name | pub(crate) fn get_destructuring_property_name(&mut self, node: P<Node>) -> (String, bool) | flow.go:1792 | Checker
get_diagnostic_head_message_for_decorator_resolution | pub(crate) fn get_diagnostic_head_message_for_decorator_resolution(node: P<Node>) -> &'static Message | checker.go:8970 | Checker
get_diagnostics | pub(crate) fn get_diagnostics(&mut self, ctx: &Context, source_file: P<SourceFile>, suggestions: bool) -> Vec<P<Diagnostic>> | checker.go:14194 | Checker
get_diagnostics_exported | pub fn get_diagnostics_exported(&mut self, ctx: &Context, source_file: P<SourceFile>) -> Vec<P<Diagnostic>> | checker.go:14186 | Checker
get_discriminant_property_access | pub(crate) fn get_discriminant_property_access(&mut self, f: P<FlowState>, expr: P<Node>, computed_type: P<Type>) -> Option<P<Node>> | flow.go:1436 | Checker
get_distributed_type_from_type_parameter | pub(crate) fn get_distributed_type_from_type_parameter(&mut self, t: P<Type>) -> P<Type> | checker.go:23460 | Checker
get_distributed_type_parameter | pub(crate) fn get_distributed_type_parameter(&mut self, node: P<Node>, t: P<Type>) -> P<Type> | checker.go:23445 | Checker
get_effective_call_arguments | pub(crate) fn get_effective_call_arguments(&mut self, node: P<Node>) -> Vec<P<Node>> | checker.go:30531 | Checker
get_effective_check_node | pub(crate) fn get_effective_check_node(argument: P<Node>) -> P<Node> | checker.go:9573 | Checker
get_effective_constraint_of_intersection | pub(crate) fn get_effective_constraint_of_intersection(&mut self, types: &[P<Type>], target_is_union: bool) -> Option<P<Type>> | relater.go:2315 | Checker
get_effective_declaration_flags | pub fn get_effective_declaration_flags(&mut self, n: P<Node>, flags_to_check: ModifierFlags) -> ModifierFlags | checker.go:3729 | Checker
get_effective_declaration_flags | pub fn get_effective_declaration_flags(&self, c: &mut Checker, node: P<Node>, flags: ModifierFlags) -> ModifierFlags | emitresolver.go:1151 | EmitResolver
get_effective_declaration_flags_exported | pub fn get_effective_declaration_flags_exported(&mut self, n: P<Node>, flags_to_check: ModifierFlags) -> ModifierFlags | exports.go:207 | Checker
get_effective_decorator_arguments | pub(crate) fn get_effective_decorator_arguments(&mut self, node: P<Node>) -> Vec<P<Node>> | checker.go:30631 | Checker
get_effective_first_argument_for_jsx_signature | pub(crate) fn get_effective_first_argument_for_jsx_signature(&mut self, signature: P<Signature>, node: P<Node>) -> P<Type> | jsx.go:925 | Checker
get_effective_parameter_declaration | pub(crate) fn get_effective_parameter_declaration(symbol: P<Symbol>) -> Option<P<Node>> | nodebuilderimpl.go:1715 | -
get_effective_property_name_for_property_name_node | pub(crate) fn get_effective_property_name_for_property_name_node(&mut self, node: P<Node>) -> (String, bool) | checker.go:19047 | Checker
get_effective_rest_type | pub(crate) fn get_effective_rest_type(&mut self, signature: P<Signature>) -> Option<P<Type>> | relater.go:1899 | Checker
get_effective_set_accessor_type_annotation_node | pub(crate) fn get_effective_set_accessor_type_annotation_node(node: P<Node>) -> Option<P<Node>> | checker.go:20459 | -
get_effective_type_argument_at_index | pub(crate) fn get_effective_type_argument_at_index(&mut self, node: P<Node>, type_parameters: &[P<Type>], index: usize) -> P<Type> | checker.go:17536 | Checker
get_effective_type_arguments | pub(crate) fn get_effective_type_arguments(&mut self, node: P<Node>, type_parameters: &[P<Type>]) -> Vec<P<Type>> | checker.go:22329 | Checker
get_effects_signature | pub(crate) fn get_effects_signature(&mut self, node: P<Node>) -> Option<P<Signature>> | flow.go:2047 | Checker
get_elaboration_element_for_jsx_child | pub(crate) fn get_elaboration_element_for_jsx_child(child: P<Node>, name_type: P<Type>, get_invalid_text_diagnostic: InvalidTextDiagnosticFn) -> JsxElaborationElement | jsx.go:393 | Checker
get_element_access_expression_name | pub fn get_element_access_expression_name(&self, c: &mut Checker, expression: P<Node>) -> String | emitresolver.go:924 | EmitResolver
get_element_type_of_array_type | pub(crate) fn get_element_type_of_array_type(&mut self, t: P<Type>) -> Option<P<Type>> | checker.go:23974 | Checker
get_element_type_of_array_type_exported | pub fn get_element_type_of_array_type_exported(&mut self, t: P<Type>) -> Option<P<Type>> | services.go:257 | Checker
get_element_type_of_evolving_array_type | pub(crate) fn get_element_type_of_evolving_array_type(&self, t: P<Type>) -> P<Type> | flow.go:1520 | Checker
get_element_type_of_slice_of_tuple_type | pub(crate) fn get_element_type_of_slice_of_tuple_type(&mut self, t: P<Type>, index: usize, end_skip_count: usize, writing: bool, no_reductions: bool) -> Option<P<Type>> | checker.go:25300 | Checker
get_element_types | pub(crate) fn get_element_types(&mut self, t: P<Type>) -> &'static [P<Type>] | checker.go:23929 | Checker
get_emit_resolver | pub fn get_emit_resolver(&mut self) -> P<EmitResolver> | checker.go:32656 | Checker
get_emit_syntax_for_module_specifier_expression | pub(crate) fn get_emit_syntax_for_module_specifier_expression(&self, usage: P<Node>) -> ModuleKind | checker.go:15120 | Checker
get_enclosing_class_from_this_parameter | pub(crate) fn get_enclosing_class_from_this_parameter(&mut self, node: P<Node>) -> Option<P<Type>> | checker.go:12190 | Checker
get_enclosing_container | pub(crate) fn get_enclosing_container(node: P<Node>) -> Option<P<Node>> | utilities.go:1298 | -
get_enclosing_declaration_ignoring_fake_scope | pub(crate) fn get_enclosing_declaration_ignoring_fake_scope(&self, c: &Checker) -> Option<P<Node>> | nodecopy.go:280 | NodeBuilderImpl
get_end_element_count | pub(crate) fn get_end_element_count(t: &'static TupleType, flags: ElementFlags) -> usize | checker.go:23916 | -
get_entity_name_for_decorator_metadata | pub(crate) fn get_entity_name_for_decorator_metadata(&mut self, node: Option<P<Node>>) -> Option<P<Node>> | checker.go:29219 | Checker
get_entity_name_for_decorator_metadata_from_type_list | pub(crate) fn get_entity_name_for_decorator_metadata_from_type_list(&mut self, type_nodes: &[P<Node>]) -> Option<P<Node>> | checker.go:29240 | Checker
get_entity_name_for_extending_interface | pub(crate) fn get_entity_name_for_extending_interface(node: P<Node>) -> Option<P<Node>> | checker.go:11879 | Checker
get_enum_literal_type | pub(crate) fn get_enum_literal_type(&mut self, value: LiteralValue, enum_symbol: P<Symbol>, symbol: P<Symbol>) -> P<Type> | checker.go:25832 | Checker
get_enum_member_value | pub(crate) fn get_enum_member_value(&mut self, node: P<Node>) -> evaluator::Result | checker.go:24382 | Checker
get_enum_member_value | pub fn get_enum_member_value(&self, c: &mut Checker, node: P<Node>) -> evaluator::Result | emitresolver.go:89 | EmitResolver
get_erased_signature | pub(crate) fn get_erased_signature(&mut self, signature: P<Signature>) -> P<Signature> | checker.go:19737 | Checker
get_error_node_for_call_node | pub(crate) fn get_error_node_for_call_node(node: P<Node>) -> P<Node> | checker.go:10035 | -
get_error_state | pub(crate) fn get_error_state(&self, _c: &mut Checker) -> errorState | relater.go:3212 | Relater
get_error_type | pub fn get_error_type(&self) -> P<Type> | exports.go:36 | Checker
get_es_decorator_call_signature | pub(crate) fn get_es_decorator_call_signature(&mut self, decorator: P<Node>) -> Option<P<Signature>> | checker.go:30718 | Checker
get_es_symbol_like_type_for_node | pub(crate) fn get_es_symbol_like_type_for_node(&mut self, node: P<Node>) -> P<Type> | checker.go:23407 | Checker
get_es_symbol_type | pub fn get_es_symbol_type(&self) -> P<Type> | exports.go:52 | Checker
get_evolving_array_type | pub(crate) fn get_evolving_array_type(&mut self, element_type: P<Type>) -> P<Type> | flow.go:1509 | Checker
get_exact_optional_unassignable_properties | pub(crate) fn get_exact_optional_unassignable_properties(&mut self, source: P<Type>, target: P<Type>) -> Vec<P<Symbol>> | checker.go:13325 | Checker
get_excluded_symbol_flags | pub(crate) fn get_excluded_symbol_flags(flags: SymbolFlags) -> SymbolFlags | checker.go:14516 | -
get_existing_node_tree_visitor | pub(crate) fn get_existing_node_tree_visitor(c: &Checker, b: P<NodeBuilderImpl>, bound: P<recoveryBoundary>) -> NodeVisitor | nodecopy.go:288 | -
get_expanded_parameters | pub(crate) fn get_expanded_parameters(&mut self, sig: P<Signature>, skip_union_expanding: bool) -> Vec<Vec<P<Symbol>>> | nodebuilderimpl.go:1984 | Checker
get_expanded_parameters_exported | pub fn get_expanded_parameters_exported(&mut self, signature: P<Signature>, skip_union_expanding: bool) -> Vec<Vec<P<Symbol>>> | exports.go:255 | Checker
get_explicit_this_type | pub(crate) fn get_explicit_this_type(&mut self, node: P<Node>) -> Option<P<Type>> | flow.go:2215 | Checker
get_explicit_type_of_symbol | pub(crate) fn get_explicit_type_of_symbol(&mut self, symbol: P<Symbol>, diagnostic: Option<P<Diagnostic>>) -> Option<P<Type>> | flow.go:2155 | Checker
get_explicit_type_of_symbol_worker | fn get_explicit_type_of_symbol_worker(&mut self, symbol: P<Symbol>, diagnostic: Option<P<Diagnostic>>) -> Option<P<Type>> | rust:flow.rs:2902 | Checker
get_export_of_module | pub(crate) fn get_export_of_module(&mut self, symbol: P<Symbol>, name_text: &str, specifier: P<Node>, dont_resolve_alias: bool) -> Option<P<Symbol>> | checker.go:15032 | Checker
get_export_specifier_local_target_symbol | pub fn get_export_specifier_local_target_symbol(&mut self, node: P<Node>) -> Option<P<Symbol>> | services.go:476 | Checker
get_export_symbol_of_symbol | pub fn get_export_symbol_of_symbol(&mut self, symbol: P<Symbol>) -> P<Symbol> | services.go:472 | Checker
get_export_symbol_of_value_symbol_if_exported | pub(crate) fn get_export_symbol_of_value_symbol_if_exported(&mut self, symbol: Option<P<Symbol>>) -> Option<P<Symbol>> | checker.go:14612 | Checker
get_exports_and_properties_of_module | pub fn get_exports_and_properties_of_module(&mut self, module_symbol: P<Symbol>) -> Vec<P<Symbol>> | services.go:841 | Checker
get_exports_of_module | pub(crate) fn get_exports_of_module(&mut self, module_symbol: P<Symbol>) -> P<SymbolTable> | checker.go:16454 | Checker
get_exports_of_module_as_array | pub(crate) fn get_exports_of_module_as_array(&mut self, module_symbol: P<Symbol>) -> Vec<P<Symbol>> | services.go:853 | Checker
get_exports_of_module_exported | pub fn get_exports_of_module_exported(&mut self, symbol: P<Symbol>) -> Vec<P<Symbol>> | services.go:132 | Checker
get_exports_of_module_worker | pub(crate) fn get_exports_of_module_worker(&mut self, module_symbol: Option<P<Symbol>>) -> (P<SymbolTable>, FxHashMap<String, P<Node>>) | checker.go:16471 | Checker
get_exports_of_symbol | pub(crate) fn get_exports_of_symbol(&mut self, symbol: P<Symbol>) -> Option<P<SymbolTable>> | checker.go:16243 | Checker
get_external_module_container | pub(crate) fn get_external_module_container(&mut self, declaration: P<Node>) -> Option<P<Symbol>> | symbolaccessibility.go:253 | Checker
get_external_module_file_from_declaration | pub(crate) fn get_external_module_file_from_declaration(&mut self, declaration: P<Node>) -> Option<P<SourceFile>> | checker.go:15372 | Checker
get_external_module_file_from_declaration | pub fn get_external_module_file_from_declaration(&self, c: &mut Checker, declaration: P<Node>) -> Option<P<SourceFile>> | emitresolver.go:832 | EmitResolver
get_external_module_member | pub(crate) fn get_external_module_member(&mut self, node: P<Node>, specifier: P<Node>, dont_resolve_alias: bool) -> Option<P<Symbol>> | checker.go:14905 | Checker
get_external_module_require_argument | pub(crate) fn get_external_module_require_argument(node: P<Node>) -> Option<P<Node>> | utilities.go:233 | -
get_extract_string_type | pub(crate) fn get_extract_string_type(&mut self, t: P<Type>) -> P<Type> | checker.go:27179 | Checker
get_false_type_from_conditional_type | pub(crate) fn get_false_type_from_conditional_type(&mut self, t: P<Type>) -> P<Type> | checker.go:25017 | Checker
get_false_type_of_conditional_type | pub fn get_false_type_of_conditional_type(&mut self, t: P<Type>) -> P<Type> | exports.go:199 | Checker
get_feature_map | pub fn get_feature_map() -> &'static FxHashMap<&'static str, Vec<FeatureMapEntry>> | rust:utilities_types.rs:40 | -
get_file_symbol_if_file_symbol_export_equals_container | pub(crate) fn get_file_symbol_if_file_symbol_export_equals_container(&mut self, d: P<Node>, container: P<Symbol>) -> Option<P<Symbol>> | symbolaccessibility.go:261 | Checker
get_final_array_type | pub(crate) fn get_final_array_type(&mut self, t: &'static EvolvingArrayType) -> P<Type> | flow.go:1573 | Checker
get_first_declaration | pub(crate) fn get_first_declaration(symbol: P<Symbol>) -> Option<P<Node>> | checker.go:14509 | -
get_first_non_ambient_class_or_function_declaration | pub(crate) fn get_first_non_ambient_class_or_function_declaration(symbol: P<Symbol>) -> Option<P<Node>> | checker.go:5357 | -
get_first_transformable_static_class_element | pub(crate) fn get_first_transformable_static_class_element(&self, node: P<Node>) -> Option<P<Node>> | checker.go:10246 | Checker
get_first_type_argument_from_known_type | pub fn get_first_type_argument_from_known_type(&mut self, t: P<Type>) -> Option<P<Type>> | services.go:1009 | Checker
get_flow_node_of_node | pub(crate) fn get_flow_node_of_node(node: P<Node>) -> Option<P<FlowNode>> | flow.go:69 | -
get_flow_reference_key | pub(crate) fn get_flow_reference_key(&mut self, f: P<FlowState>) -> CacheHashKey | flow.go:1657 | Checker
get_flow_state | pub(crate) fn get_flow_state(&mut self) -> P<FlowState> | flow.go:52 | Checker
get_flow_type_in_constructor | pub(crate) fn get_flow_type_in_constructor(&mut self, symbol: P<Symbol>, constructor: P<Node>) -> Option<P<Type>> | flow.go:2466 | Checker
get_flow_type_in_static_blocks | pub(crate) fn get_flow_type_in_static_blocks(&mut self, symbol: P<Symbol>, static_blocks: &[P<Node>]) -> Option<P<Type>> | flow.go:2488 | Checker
get_flow_type_of_access_expression | pub(crate) fn get_flow_type_of_access_expression(&mut self, node: P<Node>, prop: Option<P<Symbol>>, prop_type: P<Type>, error_node: P<Node>, check_mode: CheckMode) -> P<Type> | checker.go:11592 | Checker
get_flow_type_of_destructuring | pub(crate) fn get_flow_type_of_destructuring(&mut self, node: P<Node>, declared_type: P<Type>) -> P<Type> | checker.go:18189 | Checker
get_flow_type_of_property | pub(crate) fn get_flow_type_of_property(&mut self, reference: P<Node>, prop: Option<P<Symbol>>) -> P<Type> | checker.go:11645 | Checker
get_flow_type_of_reference | pub fn get_flow_type_of_reference(&mut self, reference: P<Node>, declared_type: P<Type>) -> P<Type> | flow.go:77 | Checker
get_flow_type_of_reference_ex | pub(crate) fn get_flow_type_of_reference_ex(&mut self, reference: P<Node>, declared_type: P<Type>, initial_type: P<Type>, flow_container: Option<P<Node>>, flow_node: Option<P<FlowNode>>) -> P<Type> | flow.go:81 | Checker
get_for_in_variable_symbol | pub(crate) fn get_for_in_variable_symbol(&mut self, node: P<Node>) -> Option<P<Symbol>> | checker.go:8371 | Checker
get_fresh_type_of_literal_type | pub(crate) fn get_fresh_type_of_literal_type(&mut self, t: P<Type>) -> P<Type> | checker.go:25757 | Checker
get_frozen | fn get_frozen(&self, v: ObjectFlags) -> ObjectFlags | rust:types.rs:1247 | ObjectFlagsCell
get_fully_qualified_name | pub(crate) fn get_fully_qualified_name(&mut self, symbol: P<Symbol>, containing_location: Option<P<Node>>) -> String | checker.go:16236 | Checker
get_fully_qualified_name_exported | pub fn get_fully_qualified_name_exported(&mut self, symbol: P<Symbol>) -> String | exports.go:318 | Checker
get_generic_object_flags | pub(crate) fn get_generic_object_flags(&mut self, t: P<Type>) -> ObjectFlags | checker.go:25350 | Checker
get_global_async_disposable_type | pub(crate) fn get_global_async_disposable_type(&mut self) -> P<Type> | rust:checker.rs:2560 | Checker
get_global_async_generator_type | pub(crate) fn get_global_async_generator_type(&mut self) -> P<Type> | rust:checker.rs:2821 | Checker
get_global_async_iterable_iterator_type | pub(crate) fn get_global_async_iterable_iterator_type(&mut self) -> P<Type> | rust:checker.rs:2794 | Checker
get_global_async_iterable_iterator_type_checked | pub(crate) fn get_global_async_iterable_iterator_type_checked(&mut self) -> P<Type> | rust:checker.rs:2803 | Checker
get_global_async_iterable_type | pub(crate) fn get_global_async_iterable_type(&mut self) -> P<Type> | rust:checker.rs:2776 | Checker
get_global_async_iterable_type_checked | pub(crate) fn get_global_async_iterable_type_checked(&mut self) -> P<Type> | rust:checker.rs:2785 | Checker
get_global_async_iterator_object_type | pub(crate) fn get_global_async_iterator_object_type(&mut self) -> P<Type> | rust:checker.rs:2812 | Checker
get_global_async_iterator_type | pub(crate) fn get_global_async_iterator_type(&mut self) -> P<Type> | rust:checker.rs:2767 | Checker
get_global_awaited_symbol | pub(crate) fn get_global_awaited_symbol(&mut self) -> Option<P<Symbol>> | rust:checker.rs:2569 | Checker
get_global_awaited_symbol_or_nil | pub(crate) fn get_global_awaited_symbol_or_nil(&mut self) -> Option<P<Symbol>> | rust:checker.rs:2578 | Checker
get_global_big_int_type | pub(crate) fn get_global_big_int_type(&mut self) -> P<Type> | rust:checker.rs:2497 | Checker
get_global_builtin_iterator_types | pub fn get_global_builtin_iterator_types(&self, c: &mut Checker) -> &'static [P<Type>] | rust:checker.rs:956 | IterationTypesResolver
get_global_class_accessor_decorator_context_type | pub(crate) fn get_global_class_accessor_decorator_context_type(&mut self) -> P<Type> | rust:checker.rs:2893 | Checker
get_global_class_accessor_decorator_result_type | pub(crate) fn get_global_class_accessor_decorator_result_type(&mut self) -> P<Type> | rust:checker.rs:2911 | Checker
get_global_class_accessor_decorator_target_type | pub(crate) fn get_global_class_accessor_decorator_target_type(&mut self) -> P<Type> | rust:checker.rs:2902 | Checker
get_global_class_decorator_context_type | pub(crate) fn get_global_class_decorator_context_type(&mut self) -> P<Type> | rust:checker.rs:2857 | Checker
get_global_class_field_decorator_context_type | pub(crate) fn get_global_class_field_decorator_context_type(&mut self) -> P<Type> | rust:checker.rs:2920 | Checker
get_global_class_getter_decorator_context_type | pub(crate) fn get_global_class_getter_decorator_context_type(&mut self) -> P<Type> | rust:checker.rs:2875 | Checker
get_global_class_method_decorator_context_type | pub(crate) fn get_global_class_method_decorator_context_type(&mut self) -> P<Type> | rust:checker.rs:2866 | Checker
get_global_class_setter_decorator_context_type | pub(crate) fn get_global_class_setter_decorator_context_type(&mut self) -> P<Type> | rust:checker.rs:2884 | Checker
get_global_diagnostics | pub fn get_global_diagnostics(&mut self) -> Vec<P<Diagnostic>> | checker.go:14204 | Checker
get_global_disposable_type | pub(crate) fn get_global_disposable_type(&mut self) -> P<Type> | rust:checker.rs:2551 | Checker
get_global_es_symbol_constructor_symbol_or_nil | pub(crate) fn get_global_es_symbol_constructor_symbol_or_nil(&mut self) -> Option<P<Symbol>> | rust:checker.rs:2614 | Checker
get_global_es_symbol_constructor_type_symbol_or_nil | pub(crate) fn get_global_es_symbol_constructor_type_symbol_or_nil(&mut self) -> Option<P<Symbol>> | rust:checker.rs:2623 | Checker
get_global_es_symbol_type | pub(crate) fn get_global_es_symbol_type(&mut self) -> P<Type> | rust:checker.rs:2488 | Checker
get_global_extract_symbol | pub(crate) fn get_global_extract_symbol(&mut self) -> Option<P<Symbol>> | rust:checker.rs:2542 | Checker
get_global_generator_type | pub(crate) fn get_global_generator_type(&mut self) -> P<Type> | rust:checker.rs:2758 | Checker
get_global_generator_type | pub fn get_global_generator_type(&self, c: &mut Checker) -> P<Type> | rust:checker.rs:953 | IterationTypesResolver
get_global_import_attributes_type | pub(crate) fn get_global_import_attributes_type(&mut self) -> P<Type> | rust:checker.rs:2515 | Checker
get_global_import_attributes_type_checked | pub(crate) fn get_global_import_attributes_type_checked(&mut self) -> P<Type> | rust:checker.rs:2524 | Checker
get_global_import_call_options_type | pub(crate) fn get_global_import_call_options_type(&mut self) -> P<Type> | rust:checker.rs:2632 | Checker
get_global_import_call_options_type_checked | pub(crate) fn get_global_import_call_options_type_checked(&mut self) -> P<Type> | rust:checker.rs:2641 | Checker
get_global_import_meta_expression_type | pub(crate) fn get_global_import_meta_expression_type(&mut self) -> P<Type> | checker.go:25152 | Checker
get_global_import_meta_type | pub(crate) fn get_global_import_meta_type(&mut self) -> P<Type> | rust:checker.rs:2506 | Checker
get_global_iterable_iterator_type | pub(crate) fn get_global_iterable_iterator_type(&mut self) -> P<Type> | rust:checker.rs:2731 | Checker
get_global_iterable_iterator_type | pub fn get_global_iterable_iterator_type(&self, c: &mut Checker) -> P<Type> | rust:checker.rs:944 | IterationTypesResolver
get_global_iterable_iterator_type_checked | pub(crate) fn get_global_iterable_iterator_type_checked(&mut self) -> P<Type> | rust:checker.rs:2740 | Checker
get_global_iterable_iterator_type_checked | pub fn get_global_iterable_iterator_type_checked(&self, c: &mut Checker) -> P<Type> | rust:checker.rs:947 | IterationTypesResolver
get_global_iterable_type | pub(crate) fn get_global_iterable_type(&mut self) -> P<Type> | rust:checker.rs:2713 | Checker
get_global_iterable_type | pub fn get_global_iterable_type(&self, c: &mut Checker) -> P<Type> | rust:checker.rs:938 | IterationTypesResolver
get_global_iterable_type_checked | pub(crate) fn get_global_iterable_type_checked(&mut self) -> P<Type> | rust:checker.rs:2722 | Checker
get_global_iterable_type_checked | pub fn get_global_iterable_type_checked(&self, c: &mut Checker) -> P<Type> | rust:checker.rs:941 | IterationTypesResolver
get_global_iterator_object_type | pub(crate) fn get_global_iterator_object_type(&mut self) -> P<Type> | rust:checker.rs:2749 | Checker
get_global_iterator_object_type | pub fn get_global_iterator_object_type(&self, c: &mut Checker) -> P<Type> | rust:checker.rs:950 | IterationTypesResolver
get_global_iterator_return_result_type | pub(crate) fn get_global_iterator_return_result_type(&mut self) -> P<Type> | rust:checker.rs:2839 | Checker
get_global_iterator_type | pub(crate) fn get_global_iterator_type(&mut self) -> P<Type> | rust:checker.rs:2704 | Checker
get_global_iterator_type | pub fn get_global_iterator_type(&self, c: &mut Checker) -> P<Type> | rust:checker.rs:935 | IterationTypesResolver
get_global_iterator_yield_result_type | pub(crate) fn get_global_iterator_yield_result_type(&mut self) -> P<Type> | rust:checker.rs:2830 | Checker
get_global_nan_symbol_or_nil | pub(crate) fn get_global_nan_symbol_or_nil(&mut self) -> Option<P<Symbol>> | rust:checker.rs:2587 | Checker
get_global_non_nullable_type_alias_or_nil | pub(crate) fn get_global_non_nullable_type_alias_or_nil(&mut self) -> Option<P<Symbol>> | rust:checker.rs:2533 | Checker
get_global_non_nullable_type_instantiation | pub(crate) fn get_global_non_nullable_type_instantiation(&mut self, t: P<Type>) -> P<Type> | checker.go:31697 | Checker
get_global_omit_symbol | pub(crate) fn get_global_omit_symbol(&mut self) -> Option<P<Symbol>> | rust:checker.rs:2695 | Checker
get_global_promise_constructor_symbol | pub(crate) fn get_global_promise_constructor_symbol(&mut self) -> Option<P<Symbol>> | rust:checker.rs:2677 | Checker
get_global_promise_constructor_symbol_or_nil | pub(crate) fn get_global_promise_constructor_symbol_or_nil(&mut self) -> Option<P<Symbol>> | rust:checker.rs:2686 | Checker
get_global_promise_like_type | pub(crate) fn get_global_promise_like_type(&mut self) -> P<Type> | rust:checker.rs:2668 | Checker
get_global_promise_type | pub(crate) fn get_global_promise_type(&mut self) -> P<Type> | rust:checker.rs:2650 | Checker
get_global_promise_type_checked | pub(crate) fn get_global_promise_type_checked(&mut self) -> P<Type> | rust:checker.rs:2659 | Checker
get_global_record_symbol | pub(crate) fn get_global_record_symbol(&mut self) -> Option<P<Symbol>> | rust:checker.rs:2596 | Checker
get_global_strict_function_type | pub(crate) fn get_global_strict_function_type(&mut self, name: &str) -> P<Type> | checker.go:25145 | Checker
get_global_symbol | pub(crate) fn get_global_symbol(&mut self, name: &str, meaning: SymbolFlags, diagnostic: Option<&'static Message>) -> Option<P<Symbol>> | checker.go:1251 | Checker
get_global_symbol_exported | pub fn get_global_symbol_exported(&mut self, name: &str, meaning: SymbolFlags, diagnostic: Option<&'static Message>) -> Option<P<Symbol>> | exports.go:99 | Checker
get_global_template_strings_array_type | pub(crate) fn get_global_template_strings_array_type(&mut self) -> P<Type> | rust:checker.rs:2605 | Checker
get_global_type | pub(crate) fn get_global_type(&mut self, name: &str, arity: usize, report_errors: bool) -> P<Type> | checker.go:1220 | Checker
get_global_type_alias_symbol | pub(crate) fn get_global_type_alias_symbol(&mut self, name: &str, arity: usize, report_errors: bool) -> Option<P<Symbol>> | checker.go:1195 | Checker
get_global_type_declaration | pub(crate) fn get_global_type_declaration(symbol: P<Symbol>) -> Option<P<Node>> | checker.go:1241 | -
get_global_typed_property_descriptor_type | pub(crate) fn get_global_typed_property_descriptor_type(&mut self) -> P<Type> | rust:checker.rs:2848 | Checker
get_global_types | pub(crate) fn get_global_types(&mut self, names: &[&str], arity: usize, report_errors: bool) -> &'static [P<Type>] | rust:checker.rs:2473 | Checker
get_helper_names | pub(crate) fn get_helper_names(&self, helper: ExternalEmitHelpers) -> Vec<String> | checker.go:29093 | Checker
get_homomorphic_type_variable | pub(crate) fn get_homomorphic_type_variable(&mut self, t: P<Type>) -> Option<P<Type>> | checker.go:22949 | Checker
get_identifier_chain | pub(crate) fn get_identifier_chain(node: P<Node>) -> Vec<P<Node>> | checker.go:25120 | Checker
get_identifier_from_entity_name_expression | pub(crate) fn get_identifier_from_entity_name_expression(node: P<Node>) -> Option<P<Node>> | grammarchecks.go:58 | -
get_immediate_aliased_symbol | pub fn get_immediate_aliased_symbol(&mut self, symbol: P<Symbol>) -> Option<P<Symbol>> | checker.go:2196 | Checker
get_immediate_aliased_symbol_exported | pub fn get_immediate_aliased_symbol_exported(&mut self, symbol: P<Symbol>) -> Option<P<Symbol>> | exports.go:111 | Checker
get_immediate_root_symbols | pub(crate) fn get_immediate_root_symbols(&mut self, symbol: P<Symbol>) -> Vec<P<Symbol>> | services.go:422 | Checker
get_implied_constraint | pub(crate) fn get_implied_constraint(&mut self, t: P<Type>, check_node: P<Node>, extends_node: P<Node>) -> Option<P<Type>> | checker.go:25459 | Checker
get_import_attributes_type_for_module_specifier | pub(crate) fn get_import_attributes_type_for_module_specifier(&mut self, module_specifier: P<Node>) -> Option<P<Type>> | checker.go:5596 | Checker
get_index_info_of_type | pub fn get_index_info_of_type(&mut self, t: P<Type>, key_type: P<Type>) -> Option<P<IndexInfo>> | checker.go:19331 | Checker
get_index_info_of_type_exported | pub fn get_index_info_of_type_exported(&mut self, t: P<Type>, key_type: P<Type>) -> Option<P<IndexInfo>> | exports.go:338 | Checker
get_index_info_with_readonly | pub(crate) fn get_index_info_with_readonly(info: P<IndexInfo>, readonly: bool) -> P<IndexInfo> | checker.go:13715 | Checker
get_index_infos_of_index_symbol | pub(crate) fn get_index_infos_of_index_symbol(&mut self, index_symbol: P<Symbol>, sibling_symbols: &[P<Symbol>]) -> Vec<P<IndexInfo>> | checker.go:19975 | Checker
get_index_infos_of_structured_type | pub(crate) fn get_index_infos_of_structured_type(&mut self, t: P<Type>) -> &'static [P<IndexInfo>] | checker.go:19322 | Checker
get_index_infos_of_symbol | pub(crate) fn get_index_infos_of_symbol(&mut self, symbol: P<Symbol>) -> Vec<P<IndexInfo>> | checker.go:19966 | Checker
get_index_infos_of_type | pub fn get_index_infos_of_type(&mut self, t: P<Type>) -> &'static [P<IndexInfo>] | checker.go:19318 | Checker
get_index_infos_of_type_exported | pub fn get_index_infos_of_type_exported(&mut self, t: P<Type>) -> &'static [P<IndexInfo>] | exports.go:346 | Checker
get_index_node_for_access_expression | pub(crate) fn get_index_node_for_access_expression(access_node: P<Node>) -> Option<P<Node>> | checker.go:27727 | -
get_index_signatures_at_location | pub fn get_index_signatures_at_location(&mut self, node: P<Node>) -> Vec<P<Node>> | checker.go:32257 | Checker
get_index_signatures_at_location_exported | pub fn get_index_signatures_at_location_exported(&mut self, node: P<Node>) -> Vec<P<Node>> | exports.go:276 | Checker
get_index_symbol | pub(crate) fn get_index_symbol(&mut self, symbol: P<Symbol>) -> Option<P<Symbol>> | checker.go:20143 | Checker
get_index_type | pub(crate) fn get_index_type(&mut self, t: P<Type>) -> P<Type> | checker.go:27150 | Checker
get_index_type_ex | pub(crate) fn get_index_type_ex(&mut self, t: P<Type>, index_flags: IndexFlags) -> P<Type> | checker.go:27154 | Checker
get_index_type_ex_inner | fn get_index_type_ex_inner(&mut self, t: P<Type>, index_flags: IndexFlags) -> P<Type> | rust:checker_13.rs:1543 | Checker
get_index_type_for_generic_type | pub(crate) fn get_index_type_for_generic_type(&mut self, t: P<Type>, index_flags: IndexFlags) -> P<Type> | checker.go:27323 | Checker
get_index_type_for_mapped_type | pub(crate) fn get_index_type_for_mapped_type(&mut self, t: P<Type>, index_flags: IndexFlags) -> P<Type> | checker.go:27341 | Checker
get_index_type_of_type | pub fn get_index_type_of_type(&mut self, t: P<Type>, key_type: P<Type>) -> Option<P<Type>> | checker.go:19337 | Checker
get_index_type_of_type_ex | pub(crate) fn get_index_type_of_type_ex(&mut self, t: P<Type>, key_type: P<Type>, default_type: P<Type>) -> P<Type> | checker.go:19345 | Checker
get_index_type_of_type_exported | pub fn get_index_type_of_type_exported(&mut self, t: P<Type>, key_type: P<Type>) -> Option<P<Type>> | exports.go:342 | Checker
get_index_type_or_string | pub(crate) fn get_index_type_or_string(&mut self, t: P<Type>) -> P<Type> | checker.go:4055 | Checker
get_indexed_access_key | pub(crate) fn get_indexed_access_key(object_type: P<Type>, index_type: P<Type>, access_flags: AccessFlags, alias: AliasArg<'_>) -> CacheHashKey | checker.go:17920 | -
get_indexed_access_type | pub(crate) fn get_indexed_access_type(&mut self, object_type: P<Type>, index_type: P<Type>) -> P<Type> | checker.go:27393 | Checker
get_indexed_access_type_by_union_memoized | fn get_indexed_access_type_by_union_memoized(&mut self, object_type: P<Type>, index_type: P<Type>, access_flags: AccessFlags) -> Option<P<Type>> | rust:checker_13.rs:1861 | Checker
get_indexed_access_type_ex | pub(crate) fn get_indexed_access_type_ex(&mut self, object_type: P<Type>, index_type: P<Type>, access_flags: AccessFlags, access_node: Option<P<Node>>, alias: AliasArg<'_>) -> P<Type> | checker.go:27397 | Checker
get_indexed_access_type_or_undefined | pub fn get_indexed_access_type_or_undefined(&mut self, object_type: P<Type>, index_type: P<Type>, access_flags: AccessFlags, access_node: Option<P<Node>>, alias: AliasArg<'_>) -> Option<P<Type>> | checker.go:27405 | Checker
get_indexed_access_type_or_undefined_inner | fn get_indexed_access_type_or_undefined_inner(&mut self, object_type: P<Type>, index_type: P<Type>, access_flags: AccessFlags, access_node: Option<P<Node>>, alias: AliasArg<'_>) -> Option<P<Type>> | rust:checker_13.rs:1891 | Checker
get_indexed_mapped_type_substituted_type_of_contextual_type | pub(crate) fn get_indexed_mapped_type_substituted_type_of_contextual_type(&mut self, t: P<Type>, name: &str, name_type: Option<P<Type>>) -> Option<P<Type>> | checker.go:31096 | Checker
get_infer_type_parameters | pub(crate) fn get_infer_type_parameters(&mut self, node: P<Node>) -> Vec<P<Type>> | checker.go:24264 | Checker
get_inference_context | pub(crate) fn get_inference_context(&self, node: P<Node>) -> Option<P<InferenceContext>> | checker.go:31454 | Checker
get_inference_info_for_type | pub(crate) fn get_inference_info_for_type(n: P<InferenceState>, t: P<Type>) -> Option<P<InferenceInfo>> | inference.go:1519 | -
get_inference_state | pub(crate) fn get_inference_state(&mut self) -> P<InferenceState> | inference.go:32 | Checker
get_inferred_true_type_from_conditional_type | pub(crate) fn get_inferred_true_type_from_conditional_type(&mut self, t: P<Type>) -> P<Type> | checker.go:25025 | Checker
get_inferred_type | pub(crate) fn get_inferred_type(&mut self, n: P<InferenceContext>, index: usize) -> P<Type> | inference.go:1317 | Checker
get_inferred_type_parameter_constraint | pub(crate) fn get_inferred_type_parameter_constraint(&mut self, t: P<Type>, omit_type_references: bool) -> Option<P<Type>> | checker.go:17438 | Checker
get_inferred_types | pub(crate) fn get_inferred_types(&mut self, n: P<InferenceContext>) -> Vec<P<Type>> | inference.go:1406 | Checker
get_initial_or_assigned_type | pub(crate) fn get_initial_or_assigned_type(&mut self, f: P<FlowState>, flow: P<FlowNode>) -> P<Type> | flow.go:276 | Checker
get_initial_type | pub(crate) fn get_initial_type(&mut self, node: P<Node>) -> P<Type> | flow.go:2234 | Checker
get_initial_type_of_binding_element | pub(crate) fn get_initial_type_of_binding_element(&mut self, node: P<Node>) -> P<Type> | flow.go:2273 | Checker
get_initial_type_of_variable_declaration | pub(crate) fn get_initial_type_of_variable_declaration(&mut self, node: P<Node>) -> P<Type> | flow.go:2244 | Checker
get_instance_type | pub(crate) fn get_instance_type(&mut self, constructor_type: P<Type>) -> P<Type> | flow.go:966 | Checker
get_instantiated_constructors_for_type_arguments | pub(crate) fn get_instantiated_constructors_for_type_arguments(&mut self, t: P<Type>, type_argument_nodes: &[P<Node>], location: P<Node>) -> Vec<P<Signature>> | checker.go:19616 | Checker
get_instantiated_signatures | fn get_instantiated_signatures(c: &mut Checker, st: &InstantiationExpressionState, signatures: &'static [P<Signature>]) -> Cow<'static, [P<Signature>]> | rust:checker_06.rs:17 | -
get_instantiated_type | fn get_instantiated_type(c: &mut Checker, st: &mut InstantiationExpressionState, t: P<Type>) -> P<Type> | rust:checker_06.rs:33 | -
get_instantiated_type_part | fn get_instantiated_type_part(c: &mut Checker, st: &mut InstantiationExpressionState, has_signatures: &mut bool, has_applicable_signature: &mut bool, t: P<Type>) -> P<Type> | rust:checker_06.rs:46 | -
get_instantiation_expression_type | pub(crate) fn get_instantiation_expression_type(&mut self, expr_type: P<Type>, node: P<Node>) -> P<Type> | checker.go:10857 | Checker
get_intended_type_from_jsdoc_type_reference | pub(crate) fn get_intended_type_from_jsdoc_type_reference(&mut self, node: P<Node>) -> Option<P<Type>> | checker.go:23481 | Checker
get_intersected_signatures | pub(crate) fn get_intersected_signatures(&mut self, signatures: &[P<Signature>]) -> Option<P<Signature>> | checker.go:10511 | Checker
get_intersection_key | pub(crate) fn get_intersection_key(types: &[P<Type>], flags: IntersectionFlags, alias: AliasArg<'_>) -> CacheHashKey | checker.go:17872 | -
get_intersection_type | pub(crate) fn get_intersection_type(&mut self, types: &[P<Type>]) -> P<Type> | checker.go:26522 | Checker
get_intersection_type_ex | pub(crate) fn get_intersection_type_ex(&mut self, types: &[P<Type>], flags: IntersectionFlags, alias: AliasArg<'_>) -> P<Type> | checker.go:26526 | Checker
get_intersection_type_facts | pub(crate) fn get_intersection_type_facts(&mut self, t: P<Type>, caller_only_needs: TypeFacts) -> TypeFacts | checker.go:31607 | Checker
get_intersection_type_worker | fn get_intersection_type_worker(&mut self, types: &[P<Type>], flags: IntersectionFlags, alias: AliasArg<'_>, type_set: &mut Vec<P<Type>>) -> P<Type> | rust:checker_13.rs:587 | Checker
get_intrinsic_attributes_type_from_jsx_opening_like_element | pub(crate) fn get_intrinsic_attributes_type_from_jsx_opening_like_element(&mut self, node: P<Node>) -> Option<P<Type>> | jsx.go:1188 | Checker
get_intrinsic_attributes_type_from_string_literal_type | pub(crate) fn get_intrinsic_attributes_type_from_string_literal_type(&mut self, t: P<Type>, location: P<Node>) -> Option<P<Type>> | jsx.go:1135 | Checker
get_intrinsic_tag_symbol | pub(crate) fn get_intrinsic_tag_symbol(&mut self, node: P<Node>) -> Option<P<Symbol>> | jsx.go:1214 | Checker
get_isolated_modules_like_flag_name | pub(crate) fn get_isolated_modules_like_flag_name(&self) -> String | checker.go:5366 | Checker
get_iterated_type_or_element_type | pub(crate) fn get_iterated_type_or_element_type(&mut self, use_: IterationUse, input_type: P<Type>, sent_type: P<Type>, error_node: Option<P<Node>>, check_assignability: bool) -> Option<P<Type>> | checker.go:6276 | Checker
get_iteration_diagnostic_details | pub(crate) fn get_iteration_diagnostic_details(&mut self, use_: IterationUse, input_type: P<Type>, allows_strings: bool) -> (&'static Message, bool) | checker.go:6884 | Checker
get_iteration_type_of_generator_function_return_type | pub(crate) fn get_iteration_type_of_generator_function_return_type(&mut self, type_kind: IterationTypeKind, return_type: P<Type>, is_async_generator: bool) -> Option<P<Type>> | checker.go:6386 | Checker
get_iteration_type_of_iterable | pub(crate) fn get_iteration_type_of_iterable(&mut self, use_: IterationUse, type_kind: IterationTypeKind, input_type: P<Type>, error_node: Option<P<Node>>) -> Option<P<Type>> | checker.go:6408 | Checker
get_iteration_type_union | pub(crate) fn get_iteration_type_union(&mut self, iteration_types: &[IterationTypes], f: impl FnMut(&mut Checker, IterationTypes) -> Option<P<Type>>) -> Option<P<Type>> | checker.go:6598 | Checker
get_iteration_types_of_generator_function_return_type | pub(crate) fn get_iteration_types_of_generator_function_return_type(&mut self, t: P<Type>, is_async_generator: bool) -> IterationTypes | checker.go:6394 | Checker
get_iteration_types_of_iterable | pub(crate) fn get_iteration_types_of_iterable(&mut self, t: P<Type>, use_: IterationUse, error_node: Option<P<Node>>) -> IterationTypes | checker.go:6435 | Checker
get_iteration_types_of_iterable_fast | pub(crate) fn get_iteration_types_of_iterable_fast(&mut self, t: P<Type>, r: P<IterationTypesResolver>) -> IterationTypes | checker.go:6527 | Checker
get_iteration_types_of_iterable_slow | pub(crate) fn get_iteration_types_of_iterable_slow(&mut self, t: P<Type>, r: P<IterationTypesResolver>, error_node: Option<P<Node>>, diagnostic_output: &mut Vec<P<Diagnostic>>) -> IterationTypes | checker.go:6630 | Checker
get_iteration_types_of_iterable_worker | pub(crate) fn get_iteration_types_of_iterable_worker(&mut self, t: P<Type>, use_: IterationUse, error_node: Option<P<Node>>, no_cache: bool) -> IterationTypes | checker.go:6457 | Checker
get_iteration_types_of_iterator | pub(crate) fn get_iteration_types_of_iterator(&mut self, t: P<Type>, r: P<IterationTypesResolver>, error_node: Option<P<Node>>, diagnostic_output: Option<&mut Vec<P<Diagnostic>>>) -> IterationTypes | checker.go:6655 | Checker
get_iteration_types_of_iterator_fast | pub(crate) fn get_iteration_types_of_iterator_fast(&mut self, t: P<Type>, r: P<IterationTypesResolver>) -> IterationTypes | checker.go:6676 | Checker
get_iteration_types_of_iterator_result | pub(crate) fn get_iteration_types_of_iterator_result(&mut self, t: P<Type>) -> IterationTypes | checker.go:6819 | Checker
get_iteration_types_of_iterator_slow | pub(crate) fn get_iteration_types_of_iterator_slow(&mut self, t: P<Type>, r: P<IterationTypesResolver>, error_node: Option<P<Node>>, diagnostic_output: Option<&mut Vec<P<Diagnostic>>>) -> IterationTypes | checker.go:6703 | Checker
get_iteration_types_of_iterator_worker | pub(crate) fn get_iteration_types_of_iterator_worker(&mut self, t: P<Type>, r: P<IterationTypesResolver>, error_node: Option<P<Node>>, diagnostic_output: Option<&mut Vec<P<Diagnostic>>>) -> IterationTypes | checker.go:6665 | Checker
get_iteration_types_of_method | pub(crate) fn get_iteration_types_of_method(&mut self, t: P<Type>, resolver: P<IterationTypesResolver>, method_name: &str, error_node: Option<P<Node>>, diagnostic_output: Option<&mut Vec<P<Diagnostic>>>) -> IterationTypes | checker.go:6711 | Checker
get_jsx_element_children_property_name | pub(crate) fn get_jsx_element_children_property_name(&mut self, jsx_namespace: Option<P<Symbol>>) -> String | jsx.go:1077 | Checker
get_jsx_element_class_type_at | pub(crate) fn get_jsx_element_class_type_at(&mut self, location: P<Node>) -> Option<P<Type>> | jsx.go:1265 | Checker
get_jsx_element_properties_name | pub(crate) fn get_jsx_element_properties_name(&mut self, jsx_namespace: Option<P<Symbol>>) -> String | jsx.go:1073 | Checker
get_jsx_element_type_at | pub(crate) fn get_jsx_element_type_at(&mut self, location: P<Node>) -> P<Type> | jsx.go:1273 | Checker
get_jsx_element_type_symbol | pub(crate) fn get_jsx_element_type_symbol(&mut self, jsx_namespace: Option<P<Symbol>>) -> Option<P<Symbol>> | jsx.go:1057 | Checker
get_jsx_element_type_type_at | pub(crate) fn get_jsx_element_type_type_at(&mut self, location: P<Node>) -> Option<P<Type>> | jsx.go:1277 | Checker
get_jsx_factory_entity | pub(crate) fn get_jsx_factory_entity(&mut self, location: Option<P<Node>>) -> Option<P<Node>> | jsx.go:1404 | Checker
get_jsx_factory_entity | pub fn get_jsx_factory_entity(&self, c: &mut Checker, location: P<Node>) -> Option<P<Node>> | emitresolver.go:53 | EmitResolver
get_jsx_fragment_factory | pub fn get_jsx_fragment_factory(&mut self, location: P<Node>) -> String | exports.go:288 | Checker
get_jsx_fragment_factory_entity | pub(crate) fn get_jsx_fragment_factory_entity(&mut self, location: Option<P<Node>>) -> Option<P<Node>> | jsx.go:1414 | Checker
get_jsx_fragment_factory_entity | pub fn get_jsx_fragment_factory_entity(&self, c: &mut Checker, location: P<Node>) -> Option<P<Node>> | emitresolver.go:59 | EmitResolver
get_jsx_fragment_type | pub(crate) fn get_jsx_fragment_type(&mut self, node: P<Node>) -> P<Type> | jsx.go:500 | Checker
get_jsx_intrinsic_tag_names_at | pub fn get_jsx_intrinsic_tag_names_at(&mut self, location: P<Node>) -> &'static [P<Symbol>] | services.go:858 | Checker
get_jsx_library_managed_attributes | pub(crate) fn get_jsx_library_managed_attributes(&mut self, jsx_namespace: Option<P<Symbol>>) -> Option<P<Symbol>> | jsx.go:1050 | Checker
get_jsx_managed_attributes_from_located_attributes | pub(crate) fn get_jsx_managed_attributes_from_located_attributes(&mut self, context: P<Node>, ns: Option<P<Symbol>>, attributes_type: P<Type>) -> P<Type> | jsx.go:1018 | Checker
get_jsx_namespace | pub(crate) fn get_jsx_namespace(&mut self, location: Option<P<Node>>) -> String | jsx.go:1339 | Checker
get_jsx_namespace_at | pub(crate) fn get_jsx_namespace_at(&mut self, location: Option<P<Node>>) -> Option<P<Symbol>> | jsx.go:1304 | Checker
get_jsx_namespace_container_for_implicit_import | pub(crate) fn get_jsx_namespace_container_for_implicit_import(&mut self, location: P<Node>) -> Option<P<Symbol>> | jsx.go:1449 | Checker
get_jsx_namespace_exported | pub fn get_jsx_namespace_exported(&mut self, location: P<Node>) -> String | exports.go:284 | Checker
get_jsx_props_type_for_signature_from_member | pub(crate) fn get_jsx_props_type_for_signature_from_member(&mut self, sig: P<Signature>, forced_lookup_location: &str) -> Option<P<Type>> | jsx.go:989 | Checker
get_jsx_props_type_from_call_signature | pub(crate) fn get_jsx_props_type_from_call_signature(&mut self, sig: P<Signature>, context: P<Node>) -> P<Type> | jsx.go:932 | Checker
get_jsx_props_type_from_class_type | pub(crate) fn get_jsx_props_type_from_class_type(&mut self, sig: P<Signature>, context: P<Node>) -> P<Type> | jsx.go:942 | Checker
get_jsx_reference_kind | pub(crate) fn get_jsx_reference_kind(&mut self, node: P<Node>) -> JsxReferenceKind | jsx.go:1157 | Checker
get_jsx_runtime_import_specifier | pub(crate) fn get_jsx_runtime_import_specifier(&self, file: P<SourceFile>) -> (String, Option<P<Node>>) | jsx.go:1486 | Checker
get_jsx_stateless_element_type_at | pub(crate) fn get_jsx_stateless_element_type_at(&mut self, location: P<Node>) -> P<Type> | jsx.go:1257 | Checker
get_jsx_type | pub(crate) fn get_jsx_type(&mut self, name: &str, location: P<Node>) -> P<Type> | jsx.go:1293 | Checker
get_key_property_candidate_name | pub(crate) fn get_key_property_candidate_name(&mut self, types: &[P<Type>]) -> String | relater.go:1152 | Checker
get_key_property_name | pub(crate) fn get_key_property_name(&mut self, t: P<Type>) -> String | relater.go:1111 | Checker
get_known_keys_of_tuple_type | pub(crate) fn get_known_keys_of_tuple_type(&mut self, t: P<Type>) -> P<Type> | relater.go:1930 | Checker
get_late_bound_symbol | pub(crate) fn get_late_bound_symbol(&mut self, symbol: P<Symbol>) -> P<Symbol> | checker.go:14637 | Checker
get_late_bound_symbol_worker | fn get_late_bound_symbol_worker(&mut self, symbol: P<Symbol>) -> P<Symbol> | rust:checker_07.rs:2070 | Checker
get_lazy | pub fn get_lazy(&self) -> ObjectFlags | rust:types.rs:1238 | ObjectFlagsCell
get_lazy_declared_member | pub(crate) fn get_lazy_declared_member(&mut self, lm: P<LazyMemberTable>, symbol: P<Symbol>, name: &'static str) -> P<Symbol> | rust:checker_09.rs:3140 | Checker
get_lazy_mapped_table | pub(crate) fn get_lazy_mapped_table(&mut self, t: P<Type>) -> Option<std::rc::Rc<LazyMappedTable>> | rust:checker_10.rs:2125 | Checker
get_lazy_mapped_table_worker | fn get_lazy_mapped_table_worker(&mut self, t: P<Type>) -> Option<std::rc::Rc<LazyMappedTable>> | rust:checker_10.rs:2133 | Checker
get_lazy_mapped_type_index_infos | pub(crate) fn get_lazy_mapped_type_index_infos(&mut self, t: P<Type>, lazy: &std::rc::Rc<LazyMappedTable>) -> &'static [P<IndexInfo>] | rust:checker_10.rs:2219 | Checker
get_lazy_mapped_type_member | pub(crate) fn get_lazy_mapped_type_member(&mut self, t: P<Type>, lazy: &std::rc::Rc<LazyMappedTable>, name: &str) -> Option<Option<P<Symbol>>> | rust:checker_10.rs:2182 | Checker
get_lazy_properties_in_order | pub(crate) fn get_lazy_properties_in_order(&mut self, t: P<Type>) -> Option<Vec<P<Symbol>>> | rust:relater_1.rs:1608 | Checker
get_legacy_decorator_argument_count | pub(crate) fn get_legacy_decorator_argument_count(&mut self, node: P<Node>, signature: P<Signature>) -> usize | checker.go:9385 | Checker
get_legacy_decorator_call_signature | pub(crate) fn get_legacy_decorator_call_signature(&mut self, decorator: P<Node>) -> Option<P<Signature>> | checker.go:30651 | Checker
get_limited_constraint | pub(crate) fn get_limited_constraint(&mut self, t: P<Type>) -> Option<P<Type>> | inference.go:1158 | Checker
get_literal_property_name_text | pub(crate) fn get_literal_property_name_text(&mut self, name: P<Node>) -> (String, bool) | flow.go:1806 | Checker
get_literal_type_from_properties | pub(crate) fn get_literal_type_from_properties(&mut self, t: P<Type>, include: TypeFlags, include_origin: bool) -> P<Type> | checker.go:27187 | Checker
get_literal_type_from_property | pub(crate) fn get_literal_type_from_property(&mut self, prop: P<Symbol>, include: TypeFlags, include_non_public: bool) -> P<Type> | checker.go:27216 | Checker
get_literal_type_from_property_name | pub(crate) fn get_literal_type_from_property_name(&mut self, name: P<Node>) -> P<Type> | checker.go:27239 | Checker
get_local_jsx_namespace | pub(crate) fn get_local_jsx_namespace(&mut self, file: P<SourceFile>) -> String | jsx.go:1388 | Checker
get_local_symbol_for_export_specifier | pub(crate) fn get_local_symbol_for_export_specifier(&mut self, reference_location: P<Node>, reference_symbol: Option<P<Symbol>>, export_specifier: P<Node>) -> Option<P<Symbol>> | services.go:624 | Checker
get_local_type_parameters_of_class_or_interface_or_type_alias | pub fn get_local_type_parameters_of_class_or_interface_or_type_alias(&mut self, symbol: P<Symbol>) -> Vec<P<Type>> | checker.go:24276 | Checker
get_local_type_parameters_of_class_or_interface_or_type_alias_exported | pub fn get_local_type_parameters_of_class_or_interface_or_type_alias_exported(&mut self, symbol: P<Symbol>) -> Vec<P<Type>> | exports.go:243 | Checker
get_longest_candidate_index | pub(crate) fn get_longest_candidate_index(&mut self, candidates: &[P<Signature>], args_count: usize) -> usize | checker.go:9733 | Checker
get_lower_bound_of_key_type | pub(crate) fn get_lower_bound_of_key_type(&mut self, t: P<Type>) -> P<Type> | checker.go:21362 | Checker
get_mapped_type | pub(crate) fn get_mapped_type(&mut self, t: P<Type>, mapper: P<TypeMapper>) -> P<Type> | rust:mapper.rs:430 | Checker
get_mapped_type_modifiers | pub fn get_mapped_type_modifiers(t: P<Type>) -> MappedTypeModifiers | checker.go:29482 | -
get_mapped_type_name_type_kind | pub(crate) fn get_mapped_type_name_type_kind(&mut self, t: P<Type>) -> MappedTypeNameTypeKind | checker.go:27312 | Checker
get_mapped_type_optionality | pub(crate) fn get_mapped_type_optionality(t: P<Type>) -> std::cmp::Ordering | checker.go:29496 | -
get_mapped_type_symbol_of_property | pub fn get_mapped_type_symbol_of_property(&self, symbol: P<Symbol>) -> Option<P<Symbol>> | services.go:415 | Checker
get_mapper_from_context | pub(crate) fn get_mapper_from_context(n: Option<P<InferenceContext>>) -> Option<P<TypeMapper>> | inference.go:1414 | Checker
get_matching_union_constituent_for_object_literal | pub(crate) fn get_matching_union_constituent_for_object_literal(&mut self, union_type: P<Type>, node: P<Node>) -> Option<P<Type>> | checker.go:31274 | Checker
get_matching_union_constituent_for_type | pub(crate) fn get_matching_union_constituent_for_type(&mut self, union_type: P<Type>, t: P<Type>) -> Option<P<Type>> | relater.go:1096 | Checker
get_meaning_of_entity_name_reference | pub(crate) fn get_meaning_of_entity_name_reference(entity_name: P<Node>) -> SymbolFlags | emitresolver.go:311 | -
get_member_of_structured_type | pub(crate) fn get_member_of_structured_type(&mut self, t: P<Type>, name: &str) -> Option<P<Symbol>> | rust:checker_09.rs:3155 | Checker
get_member_of_structured_type_ex | pub(crate) fn get_member_of_structured_type_ex(&mut self, t: P<Type>, name: &str, instantiate: bool) -> Option<P<Symbol>> | rust:checker_09.rs:3160 | Checker
get_member_of_unresolved_structured_type | pub(crate) fn get_member_of_unresolved_structured_type(&mut self, t: P<Type>, name: &str, instantiate: bool) -> Option<P<Symbol>> | rust:checker_09.rs:3170 | Checker
get_member_override_modifier_status | pub(crate) fn get_member_override_modifier_status(&mut self, node: P<Node>, member: P<Node>, member_symbol: Option<P<Symbol>>) -> MemberOverrideStatus | checker.go:4790 | Checker
get_member_override_modifier_status_exported | pub fn get_member_override_modifier_status_exported(&mut self, node: P<Node>, member: P<Node>, member_symbol: Option<P<Symbol>>) -> MemberOverrideStatus | exports.go:326 | Checker
get_members_of_declaration | pub(crate) fn get_members_of_declaration(node: P<Node>) -> Vec<P<Node>> | utilities.go:1140 | -
get_members_of_symbol | pub(crate) fn get_members_of_symbol(&mut self, symbol: P<Symbol>) -> Option<P<SymbolTable>> | checker.go:16447 | Checker
get_merged_symbol | pub fn get_merged_symbol(&mut self, symbol: P<Symbol>) -> P<Symbol> | checker.go:14584 | Checker
get_merged_symbol_exported | pub fn get_merged_symbol_exported(&mut self, symbol: P<Symbol>) -> P<Symbol> | exports.go:103 | Checker
get_min_argument_count | pub(crate) fn get_min_argument_count(&mut self, signature: P<Signature>) -> usize | relater.go:1737 | Checker
get_min_argument_count_ex | pub(crate) fn get_min_argument_count_ex(&mut self, signature: P<Signature>, flags: MinArgumentCountFlags) -> usize | relater.go:1741 | Checker
get_min_type_argument_count | pub fn get_min_type_argument_count(type_parameters: &[P<Type>]) -> usize | checker.go:22334 | Checker
get_min_type_argument_count_exported | pub fn get_min_type_argument_count_exported(type_parameters: &[P<Type>]) -> usize | exports.go:358 | Checker
get_modified_readonly_state | pub(crate) fn get_modified_readonly_state(state: bool, modifiers: MappedTypeModifiers) -> bool | checker.go:23085 | -
get_modifiers_type_from_mapped_type | pub(crate) fn get_modifiers_type_from_mapped_type(&mut self, t: P<Type>) -> P<Type> | checker.go:28597 | Checker
get_module_specifier_for_import_or_export | pub(crate) fn get_module_specifier_for_import_or_export(node: P<Node>) -> Option<P<Node>> | checker.go:15273 | Checker
get_module_specifier_from_node | pub(crate) fn get_module_specifier_from_node(node: P<Node>) -> Option<P<Node>> | checker.go:15295 | -
get_module_specifier_override | pub(crate) fn get_module_specifier_override(&self, c: &mut Checker, parent: P<Node>, lit: P<Node>) -> String | nodecopy.go:234 | NodeBuilderImpl
get_mutable_array_or_tuple_type | pub(crate) fn get_mutable_array_or_tuple_type(&mut self, t: P<Type>) -> P<Type> | checker.go:30060 | Checker
get_name_from_index_info | pub(crate) fn get_name_from_index_info(info: P<IndexInfo>) -> String | checker.go:28266 | -
get_name_from_jsx_element_attributes_container | pub(crate) fn get_name_from_jsx_element_attributes_container(&mut self, name_of_attrib_prop_container: &str, jsx_namespace: Option<P<Symbol>>) -> String | jsx.go:1091 | Checker
get_name_of_symbol_as_written | pub(crate) fn get_name_of_symbol_as_written(&self, c: &mut Checker, symbol: P<Symbol>) -> String | nodebuilderimpl.go:973 | NodeBuilderImpl
get_name_of_symbol_from_name_type | pub(crate) fn get_name_of_symbol_from_name_type(&self, c: &mut Checker, symbol: P<Symbol>) -> String | nodebuilderimpl.go:936 | NodeBuilderImpl
get_name_type_from_mapped_type | pub(crate) fn get_name_type_from_mapped_type(&mut self, t: P<Type>) -> Option<P<Type>> | checker.go:23111 | Checker
get_name_type_of_symbol | pub fn get_name_type_of_symbol(&self, symbol: P<Symbol>) -> Option<P<Type>> | exports.go:84 | Checker
get_nameable_declaration_at_position | pub(crate) fn get_nameable_declaration_at_position(&mut self, signature: P<Signature>, pos: usize) -> Option<P<Node>> | relater.go:1860 | Checker
get_named_members | pub(crate) fn get_named_members(&mut self, members: Option<P<SymbolTable>>, container: Option<P<Symbol>>) -> Vec<P<Symbol>> | checker.go:22445 | Checker
get_narrowable_type_for_flow_reference | pub(crate) fn get_narrowable_type_for_flow_reference(&mut self, t: P<Type>, reference: P<Node>) -> (P<Type>, bool) | rust:checker_15.rs:1815 | Checker
get_narrowable_type_for_reference | pub(crate) fn get_narrowable_type_for_reference(&mut self, t: P<Type>, reference: P<Node>, check_mode: CheckMode) -> P<Type> | checker.go:31980 | Checker
get_narrowed_type | pub(crate) fn get_narrowed_type(&mut self, t: P<Type>, candidate: P<Type>, assume_true: bool, check_derived: bool) -> P<Type> | flow.go:846 | Checker
get_narrowed_type_of_symbol | pub(crate) fn get_narrowed_type_of_symbol(&mut self, symbol: P<Symbol>, location: P<Node>) -> P<Type> | checker.go:13958 | Checker
get_narrowed_type_worker | pub(crate) fn get_narrowed_type_worker(&mut self, t: P<Type>, candidate: P<Type>, assume_true: bool, check_derived: bool) -> P<Type> | flow.go:859 | Checker
get_never_type | pub fn get_never_type(&self) -> P<Type> | exports.go:40 | Checker
get_next_base_constraint | pub(crate) fn get_next_base_constraint(&mut self, t: Option<P<Type>>, stack: BaseConstraintStack<'_>) -> Option<P<Type>> | checker.go:28063 | Checker
get_no_infer_type | pub(crate) fn get_no_infer_type(&mut self, t: P<Type>) -> P<Type> | checker.go:27864 | Checker
get_node_builder | pub(crate) fn get_node_builder(&mut self) -> (P<NodeBuilder>, Box<dyn FnMut(&mut Checker)>) | nodebuilder.go:288 | Checker
get_node_builder_ex | pub(crate) fn get_node_builder_ex(&self, id_to_symbol: Option<P<RefCell<FxHashMap<P<Node>, P<Symbol>>>>>) -> P<NodeBuilder> | nodebuilder.go:299 | Checker
get_non_array_rest_type | pub(crate) fn get_non_array_rest_type(&mut self, signature: P<Signature>) -> Option<P<Type>> | relater.go:1891 | Checker
get_non_circular_return_type_of_signature | pub(crate) fn get_non_circular_return_type_of_signature(&mut self, sig: P<Signature>) -> P<Type> | checker.go:20392 | Checker
get_non_distributed_type_parameter | pub(crate) fn get_non_distributed_type_parameter(t: P<Type>) -> Option<P<Type>> | checker.go:23470 | -
get_non_missing_type_of_symbol | pub fn get_non_missing_type_of_symbol(&mut self, symbol: P<Symbol>) -> P<Type> | checker.go:16847 | Checker
get_non_missing_type_of_symbol_exported | pub fn get_non_missing_type_of_symbol_exported(&mut self, symbol: P<Symbol>) -> P<Type> | exports.go:187 | Checker
get_non_nullable_type | pub fn get_non_nullable_type(&mut self, t: P<Type>) -> P<Type> | checker.go:19007 | Checker
get_non_nullable_type_if_needed | pub(crate) fn get_non_nullable_type_if_needed(&mut self, t: P<Type>) -> P<Type> | checker.go:19018 | Checker
get_non_optional_type | pub fn get_non_optional_type(&mut self, t: P<Type>) -> P<Type> | services.go:245 | Checker
get_non_primitive_type | pub fn get_non_primitive_type(&self) -> P<Type> | exports.go:56 | Checker
get_non_rest_parameter_count | pub(crate) fn get_non_rest_parameter_count(sig: P<Signature>) -> usize | utilities.go:1312 | -
get_non_undefined_type | pub(crate) fn get_non_undefined_type(&mut self, t: P<Type>) -> P<Type> | checker.go:32037 | Checker
get_normalized_tuple_type | pub(crate) fn get_normalized_tuple_type(&mut self, t: P<Type>, writing: bool) -> P<Type> | checker.go:28543 | Checker
get_normalized_type | pub(crate) fn get_normalized_type(&mut self, t: P<Type>, writing: bool) -> P<Type> | checker.go:28335 | Checker
get_normalized_type_worker | fn get_normalized_type_worker(&mut self, t: P<Type>, writing: bool) -> P<Type> | rust:checker_14.rs:66 | Checker
get_normalized_union_or_intersection_type | pub(crate) fn get_normalized_union_or_intersection_type(&mut self, t: P<Type>, writing: bool) -> P<Type> | checker.go:28510 | Checker
get_not_equal_facts_from_typeof_switch | pub(crate) fn get_not_equal_facts_from_typeof_switch(start: usize, end: usize, witnesses: &[&str]) -> TypeFacts | flow.go:2012 | Checker
get_null_type | pub fn get_null_type(&self) -> P<Type> | exports.go:28 | Checker
get_nullable_type | pub(crate) fn get_nullable_type(&mut self, t: P<Type>, flags: TypeFlags) -> P<Type> | checker.go:18994 | Checker
get_number_index_type | pub fn get_number_index_type(&mut self, t: P<Type>) -> Option<P<Type>> | services.go:253 | Checker
get_number_literal_type | pub(crate) fn get_number_literal_type(&mut self, value: Number) -> P<Type> | checker.go:25784 | Checker
get_number_literal_value | pub(crate) fn get_number_literal_value(t: P<Type>) -> Number | checker.go:25820 | -
get_number_type | pub fn get_number_type(&self) -> P<Type> | exports.go:12 | Checker
get_object_literal_index_info | pub(crate) fn get_object_literal_index_info(&mut self, is_readonly: bool, properties: &[P<Symbol>], key_type: P<Type>) -> P<IndexInfo> | checker.go:20062 | Checker
get_object_type_instantiation | pub(crate) fn get_object_type_instantiation(&mut self, t: P<Type>, m: Option<P<TypeMapper>>, alias: Option<P<TypeAlias>>) -> P<Type> | checker.go:22729 | Checker
get_optional_call_signature | pub(crate) fn get_optional_call_signature(&mut self, signature: P<Signature>, call_chain_flags: SignatureFlags) -> P<Signature> | checker.go:9199 | Checker
get_optional_expression_type | pub(crate) fn get_optional_expression_type(&mut self, expr_type: P<Type>, expression: P<Node>) -> P<Type> | checker.go:29534 | Checker
get_optional_type | pub(crate) fn get_optional_type(&mut self, t: P<Type>, is_property: bool) -> P<Type> | checker.go:18984 | Checker
get_or_create_substitution_type | pub(crate) fn get_or_create_substitution_type(&mut self, base_type: P<Type>, constraint: P<Type>) -> P<Type> | checker.go:27888 | Checker
get_or_create_type_from_signature | pub(crate) fn get_or_create_type_from_signature(&mut self, sig: P<Signature>) -> P<Type> | checker.go:19709 | Checker
get_outer_type_parameters | pub(crate) fn get_outer_type_parameters(&mut self, node: P<Node>, include_this_types: bool) -> Vec<P<Type>> | checker.go:24226 | Checker
get_outer_type_parameters_of_class_or_interface | pub(crate) fn get_outer_type_parameters_of_class_or_interface(&mut self, symbol: P<Symbol>) -> Vec<P<Type>> | checker.go:24198 | Checker
get_parameter_count | pub(crate) fn get_parameter_count(&mut self, signature: P<Signature>) -> usize | relater.go:1726 | Checker
get_parameter_name_at_position | pub(crate) fn get_parameter_name_at_position(&mut self, signature: P<Signature>, pos: usize) -> String | relater.go:1962 | Checker
get_parameter_type_node_for_decorator_check | pub(crate) fn get_parameter_type_node_for_decorator_check(node: P<Node>) -> Option<P<Node>> | checker.go:29204 | Checker
get_parameter_type_of_full_signature | pub(crate) fn get_parameter_type_of_full_signature(&mut self, node: P<Node>, parameter: P<Node>) -> Option<P<Type>> | checker.go:20420 | Checker
get_parent_element_access | pub(crate) fn get_parent_element_access(&mut self, node: P<Node>) -> Option<P<Node>> | checker.go:18222 | Checker
get_parent_of_symbol | pub(crate) fn get_parent_of_symbol(&mut self, symbol: P<Symbol>) -> Option<P<Symbol>> | checker.go:14594 | Checker
get_parent_symbol_of_type_parameter | pub(crate) fn get_parent_symbol_of_type_parameter(c: &mut Checker, type_parameter: P<Type>) -> Option<P<Symbol>> | nodebuilderimpl.go:3055 | NodeBuilderImpl
get_parent_type_of_class_element | pub(crate) fn get_parent_type_of_class_element(&mut self, node: P<Node>) -> P<Type> | checker.go:31017 | Checker
get_permissive_instantiation | pub(crate) fn get_permissive_instantiation(&mut self, t: P<Type>) -> P<Type> | checker.go:24949 | Checker
get_possible_symbol_reference_nodes | pub(crate) fn get_possible_symbol_reference_nodes(source_file: P<SourceFile>, symbol_name: &str, container: Option<P<Node>>) -> Vec<P<Node>> | services.go:646 | -
get_possible_symbol_reference_positions | pub(crate) fn get_possible_symbol_reference_positions(source_file: P<SourceFile>, symbol_name: &str, container: Option<P<Node>>) -> Vec<u32> | services.go:655 | -
get_primitive_type_alias_suggestions | pub(crate) fn get_primitive_type_alias_suggestions(symbols: Option<P<SymbolTable>>) -> Vec<P<Symbol>> | checker.go:1804 | -
get_private_identifier_property_of_type | pub(crate) fn get_private_identifier_property_of_type(&mut self, left_type: P<Type>, lexically_scoped_identifier: P<Symbol>) -> Option<P<Symbol>> | checker.go:11691 | Checker
get_promised_type_of_promise | pub fn get_promised_type_of_promise(&mut self, t: P<Type>) -> Option<P<Type>> | checker.go:29389 | Checker
get_promised_type_of_promise_ex | pub(crate) fn get_promised_type_of_promise_ex(&mut self, t: P<Type>, error_node: Option<P<Node>>, this_type_for_error_out: Option<&mut Option<P<Type>>>) -> Option<P<Type>> | checker.go:29396 | Checker
get_propagating_flags_of_types | pub(crate) fn get_propagating_flags_of_types(types: &[P<Type>], exclude_kinds: TypeFlags) -> ObjectFlags | checker.go:25648 | Checker
get_properties_of_container_function | pub fn get_properties_of_container_function(&self, c: &mut Checker, node: Option<P<Node>>) -> Vec<P<Symbol>> | emitresolver.go:1257 | EmitResolver
get_properties_of_context | pub(crate) fn get_properties_of_context(&mut self, context: P<WideningContext>) -> Vec<P<Symbol>> | checker.go:18806 | Checker
get_properties_of_object_type | pub(crate) fn get_properties_of_object_type(&mut self, t: P<Type>) -> &'static [P<Symbol>] | checker.go:19198 | Checker
get_properties_of_type | pub fn get_properties_of_type(&mut self, t: P<Type>) -> &'static [P<Symbol>] | checker.go:19190 | Checker
get_properties_of_type_exported | pub fn get_properties_of_type_exported(&mut self, t: P<Type>) -> &'static [P<Symbol>] | exports.go:139 | Checker
get_properties_of_union_or_intersection_type | pub(crate) fn get_properties_of_union_or_intersection_type(&mut self, t: P<Type>) -> &'static [P<Symbol>] | checker.go:19205 | Checker
get_property_name_arg | pub(crate) fn get_property_name_arg(arg: &str) -> String | relater.go:4959 | -
get_property_name_for_known_symbol_name | pub fn get_property_name_for_known_symbol_name(&mut self, symbol_name: &str) -> String | flow.go:2107 | Checker
get_property_name_from_binding_element | pub(crate) fn get_property_name_from_binding_element(&mut self, e: P<Node>) -> String | checker.go:17174 | Checker
get_property_name_from_index | pub(crate) fn get_property_name_from_index(index_type: P<Type>, access_node: Option<P<Node>>) -> std::borrow::Cow<'static, str> | checker.go:27825 | Checker
get_property_name_from_type | pub fn get_property_name_from_type(t: P<Type>) -> std::borrow::Cow<'static, str> | utilities.go:929 | -
get_property_name_from_type_exported | pub fn get_property_name_from_type_exported(t: P<Type>) -> std::borrow::Cow<'static, str> | exports.go:95 | -
get_property_name_node_for_symbol | pub(crate) fn get_property_name_node_for_symbol(&self, c: &mut Checker, symbol: P<Symbol>, enclosing_declaration: Option<P<Node>>) -> Option<P<Node>> | nodebuilderimpl.go:2498 | NodeBuilderImpl
get_property_name_node_for_symbol_from_name_type | pub(crate) fn get_property_name_node_for_symbol_from_name_type(&self, c: &mut Checker, symbol: P<Symbol>, enclosing_declaration: Option<P<Node>>, single_quote: bool, string_named: bool, is_method: bool) -> Option<P<Node>> | nodebuilderimpl.go:2527 | NodeBuilderImpl
get_property_of_object_type | pub(crate) fn get_property_of_object_type(&mut self, t: P<Type>, name: &str) -> Option<P<Symbol>> | checker.go:21744 | Checker
get_property_of_object_type_hashed | pub(crate) fn get_property_of_object_type_hashed(&mut self, t: P<Type>, key: HashedName<'_>) -> Option<P<Symbol>> | rust:checker_10.rs:2855 | Checker
get_property_of_type | pub fn get_property_of_type(&mut self, t: P<Type>, name: &str) -> Option<P<Symbol>> | checker.go:19231 | Checker
get_property_of_type_ex | pub(crate) fn get_property_of_type_ex(&mut self, t: P<Type>, name: &str, skip_object_function_property_augment: bool, include_type_only_members: bool) -> Option<P<Symbol>> | checker.go:19243 | Checker
get_property_of_type_exported | pub fn get_property_of_type_exported(&mut self, t: P<Type>, name: &str) -> Option<P<Symbol>> | exports.go:143 | Checker
get_property_of_type_worker | pub(crate) fn get_property_of_type_worker(&mut self, t: P<Type>, name: &str, skip_object_function_property_augment: bool, include_type_only_members: bool, instantiate: bool) -> Option<P<Symbol>> | rust:checker_09.rs:2297 | Checker
get_property_of_union_or_intersection_type | pub(crate) fn get_property_of_union_or_intersection_type(&mut self, t: P<Type>, name: &str, skip_object_function_property_augment: bool) -> Option<P<Symbol>> | checker.go:21755 | Checker
get_property_of_variable | pub(crate) fn get_property_of_variable(&mut self, symbol: P<Symbol>, name: &str) -> Option<P<Symbol>> | checker.go:14981 | Checker
get_property_symbol_of_destructuring_assignment | pub fn get_property_symbol_of_destructuring_assignment(&mut self, location: P<Node>) -> Option<P<Symbol>> | services.go:1071 | Checker
get_property_symbols_from_contextual_type | pub fn get_property_symbols_from_contextual_type(&mut self, node: P<Node>, contextual_type: P<Type>, union_symbol_ok: bool) -> Vec<P<Symbol>> | services.go:1026 | Checker
get_property_type_for_index_type | pub(crate) fn get_property_type_for_index_type(&mut self, original_object_type: P<Type>, object_type: P<Type>, index_type: P<Type>, full_index_type: P<Type>, access_node: Option<P<Node>>, access_flags: AccessFlags) -> Option<P<Type>> | checker.go:27471 | Checker
get_qualified_left_meaning | pub(crate) fn get_qualified_left_meaning(right_meaning: SymbolFlags) -> SymbolFlags | symbolaccessibility.go:109 | -
get_quick_type_of_expression | pub(crate) fn get_quick_type_of_expression(&mut self, node: P<Node>) -> Option<P<Type>> | checker.go:7533 | Checker
get_ready_lazy_member_table | pub(crate) fn get_ready_lazy_member_table(&mut self, t: P<Type>) -> Option<P<LazyMemberTable>> | rust:checker_09.rs:2904 | Checker
get_ready_lazy_member_table_worker | pub(crate) fn get_ready_lazy_member_table_worker(&mut self, t: P<Type>) -> Option<P<LazyMemberTable>> | rust:checker_09.rs:2911 | Checker
get_recursion_identity | pub(crate) fn get_recursion_identity(c: &mut Checker, t: P<Type>) -> RecursionId | relater.go:810 | -
get_recursion_identity_from_target | pub(crate) fn get_recursion_identity_from_target(t: P<Type>) -> RecursionId | relater.go:840 | -
get_recursion_identity_target | pub(crate) fn get_recursion_identity_target(c: &mut Checker, t: P<Type>) -> P<Type> | relater.go:820 | -
get_recursion_identity_target_worker | fn get_recursion_identity_target_worker(c: &mut Checker, t: P<Type>) -> P<Type> | rust:relater_1.rs:1309 | -
get_reduced_apparent_type | pub(crate) fn get_reduced_apparent_type(&mut self, t: P<Type>) -> P<Type> | checker.go:22256 | Checker
get_reduced_apparent_type_worker | fn get_reduced_apparent_type_worker(&mut self, t: P<Type>) -> P<Type> | rust:checker_11.rs:701 | Checker
get_reduced_type | pub fn get_reduced_type(&mut self, t: P<Type>) -> P<Type> | checker.go:22181 | Checker
get_reduced_type_exported | pub fn get_reduced_type_exported(&mut self, t: P<Type>) -> P<Type> | exports.go:312 | Checker
get_reduced_type_worker | fn get_reduced_type_worker(&mut self, t: P<Type>) -> P<Type> | rust:checker_11.rs:566 | Checker
get_reduced_union_type | pub(crate) fn get_reduced_union_type(&mut self, union_type: P<Type>) -> P<Type> | checker.go:22240 | Checker
get_ref | pub fn get_ref(&self) -> Option<P<RefCell<FxHashMap<K, V>>>> | rust:types.rs:156 | GoMap
get_reference_candidate | pub(crate) fn get_reference_candidate(node: P<Node>) -> P<Node> | flow.go:1861 | Checker
get_reference_member_type_arguments | pub(crate) fn get_reference_member_type_arguments(&mut self, t: P<Type>, source: P<Type>) -> (&'static [P<Type>], Vec<P<Type>>) | rust:checker_09.rs:2886 | Checker
get_reference_resolver | pub(crate) fn get_reference_resolver(&self, c: &Checker) -> P<ReferenceResolver<Checker>> | emitresolver.go:842 | EmitResolver
get_reference_root | pub(crate) fn get_reference_root(node: P<Node>) -> P<Node> | flow.go:1876 | Checker
get_referenced_export_container | pub fn get_referenced_export_container(&self, c: &mut Checker, node: P<Node>, prefix_locals: bool) -> Option<P<Node>> /*SourceFile|ModuleDeclaration|EnumDeclaration*/ | emitresolver.go:858 | EmitResolver
get_referenced_import_declaration | pub fn get_referenced_import_declaration(&self, c: &mut Checker, node: P<Node>) -> Option<P<Node>> | emitresolver.go:875 | EmitResolver
get_referenced_member_value_declaration | pub fn get_referenced_member_value_declaration(&self, c: &mut Checker, node: P<Node>) -> Option<P<Node>> | emitresolver.go:935 | EmitResolver
get_referenced_value_declaration | pub fn get_referenced_value_declaration(&self, c: &mut Checker, node: P<Node>) -> Option<P<Node>> | emitresolver.go:889 | EmitResolver
get_referenced_value_declaration_unsafe | pub fn get_referenced_value_declaration_unsafe(&self, c: &mut Checker, node: P<Node>) -> Option<P<Node>> | emitresolver.go:900 | EmitResolver
get_referenced_value_declarations | pub fn get_referenced_value_declarations(&self, c: &mut Checker, node: P<Node>) -> Vec<P<Node>> | emitresolver.go:904 | EmitResolver
get_referenced_value_or_alias_symbol | pub(crate) fn get_referenced_value_or_alias_symbol(&mut self, reference: P<Node>) -> Option<P<Symbol>> | checker.go:14142 | Checker
get_references_to_symbol_in_file | pub fn get_references_to_symbol_in_file(&mut self, source_file: P<SourceFile>, symbol: P<Symbol>) -> Vec<P<Node>> | services.go:587 | Checker
get_regular_type_of_expression | pub(crate) fn get_regular_type_of_expression(&mut self, expr: P<Node>) -> P<Type> | checker.go:32608 | Checker
get_regular_type_of_literal_type | pub(crate) fn get_regular_type_of_literal_type(&mut self, t: P<Type>) -> P<Type> | checker.go:25743 | Checker
get_regular_type_of_object_literal | pub(crate) fn get_regular_type_of_object_literal(&mut self, t: P<Type>) -> P<Type> | checker.go:28629 | Checker
get_relater | pub(crate) fn get_relater(&mut self) -> P<Relater> | relater.go:2599 | Checker
get_relation_key | pub(crate) fn get_relation_key(c: &mut Checker, source: P<Type>, target: P<Type>, intersection_state: IntersectionState, is_identity: bool, ignore_constraints: bool) -> (RelationKey, bool) | checker.go:17953 | -
get_relation_key_worker | fn get_relation_key_worker(c: &mut Checker, source: P<Type>, target: P<Type>, intersection_state: IntersectionState, ignore_constraints: bool) -> (RelationKey, bool) | rust:checker_09.rs:752 | -
get_requires_scope_change_cache | pub(crate) fn get_requires_scope_change_cache(&mut self, node: P<Node>) -> Tristate | checker.go:1544 | Checker
get_resolution_mode_override | pub(crate) fn get_resolution_mode_override(&mut self, node: P<Node>, report_errors: bool) -> ModuleKind | checker.go:3383 | Checker
get_resolved_apparent_type_of_mapped_type | pub(crate) fn get_resolved_apparent_type_of_mapped_type(&mut self, t: P<Type>) -> P<Type> | checker.go:22134 | Checker
get_resolved_base_constraint | pub(crate) fn get_resolved_base_constraint(&mut self, t: P<Type>, stack: BaseConstraintStack<'_>) -> P<Type> | checker.go:27917 | Checker
get_resolved_iteration_types | pub(crate) fn get_resolved_iteration_types(&self, c: &mut Checker, yield_type: P<Type>, return_type: P<Type>, next_type: P<Type>) -> IterationTypes | checker.go:6554 | IterationTypesResolver
get_resolved_members_or_exports_of_symbol | pub(crate) fn get_resolved_members_or_exports_of_symbol(&mut self, symbol: P<Symbol>, resolution_kind: MembersOrExportsResolutionKind) -> Option<P<SymbolTable>> | checker.go:16253 | Checker
get_resolved_property | pub(crate) fn get_resolved_property(&mut self, source: &ResolvedPropertySource, name: &str) -> Option<P<Symbol>> | rust:checker_09.rs:2376 | Checker
get_resolved_signature | pub fn get_resolved_signature(&mut self, node: P<Node>, candidates_out_array: Option<&mut Vec<P<Signature>>>, check_mode: CheckMode) -> P<Signature> | checker.go:8581 | Checker
get_resolved_signature_exported | pub fn get_resolved_signature_exported(&mut self, node: P<Node>) -> P<Signature> | exports.go:259 | Checker
get_resolved_signature_for_signature_help | pub fn get_resolved_signature_for_signature_help(node: P<Node>, argument_count: usize, c: &mut Checker) -> (Option<P<Signature>>, Vec<P<Signature>>) | services.go:355 | -
get_resolved_signature_worker | pub(crate) fn get_resolved_signature_worker(&mut self, node: P<Node>, check_mode: CheckMode, argument_count: usize) -> (Option<P<Signature>>, Vec<P<Signature>>) | services.go:899 | Checker
get_resolved_symbol | pub fn get_resolved_symbol(&mut self, node: P<Node>) -> P<Symbol> | checker.go:14125 | Checker
get_resolved_symbol_exported | pub fn get_resolved_symbol_exported(&mut self, node: P<Node>) -> P<Symbol> | exports.go:280 | Checker
get_resolved_symbol_or_nil | pub(crate) fn get_resolved_symbol_or_nil(&mut self, node: P<Node>) -> Option<P<Symbol>> | checker.go:14138 | Checker
get_resolved_type_parameter_default | pub(crate) fn get_resolved_type_parameter_default(&mut self, t: P<Type>) -> P<Type> | checker.go:22403 | Checker
get_resolved_type_without_abstract_construct_signatures | pub(crate) fn get_resolved_type_without_abstract_construct_signatures(c: &mut Checker, t: P<Type>) -> P<Type> | nodebuilderimpl.go:564 | NodeBuilderImpl
get_rest_array_type_of_tuple_type | pub(crate) fn get_rest_array_type_of_tuple_type(&mut self, t: P<Type>) -> Option<P<Type>> | relater.go:1940 | Checker
get_rest_or_any_type_at_position | pub(crate) fn get_rest_or_any_type_at_position(&mut self, source: P<Signature>, pos: usize) -> P<Type> | relater.go:1819 | Checker
get_rest_type | pub(crate) fn get_rest_type(&mut self, source: P<Type>, properties: &[P<Node>], symbol: Option<P<Symbol>>) -> P<Type> | checker.go:18132 | Checker
get_rest_type_at_position | pub(crate) fn get_rest_type_at_position(&mut self, source: P<Signature>, pos: usize, readonly: bool) -> P<Type> | relater.go:1829 | Checker
get_rest_type_of_signature | pub(crate) fn get_rest_type_of_signature(&mut self, signature: P<Signature>) -> P<Type> | checker.go:9823 | Checker
get_rest_type_of_signature_exported | pub fn get_rest_type_of_signature_exported(&mut self, sig: P<Signature>) -> P<Type> | exports.go:330 | Checker
get_rest_type_of_tuple_type | pub(crate) fn get_rest_type_of_tuple_type(&mut self, t: P<Type>) -> Option<P<Type>> | checker.go:25321 | Checker
get_restrictive_instantiation | pub(crate) fn get_restrictive_instantiation(&mut self, t: P<Type>) -> P<Type> | checker.go:24962 | Checker
get_restrictive_type_parameter | pub(crate) fn get_restrictive_type_parameter(&mut self, t: P<Type>) -> P<Type> | checker.go:24981 | Checker
get_return_type_from_annotation | pub(crate) fn get_return_type_from_annotation(&mut self, declaration: P<Node>) -> Option<P<Type>> | checker.go:20399 | Checker
get_return_type_from_body | pub(crate) fn get_return_type_from_body(&mut self, fn_: P<Node>, check_mode: CheckMode) -> P<Type> | checker.go:20467 | Checker
get_return_type_of_full_signature | pub(crate) fn get_return_type_of_full_signature(&mut self, node: P<Node>) -> Option<P<Type>> | checker.go:20432 | Checker
get_return_type_of_signature | pub fn get_return_type_of_signature(&mut self, sig: P<Signature>) -> P<Type> | checker.go:20342 | Checker
get_return_type_of_signature_exported | pub fn get_return_type_of_signature_exported(&mut self, sig: P<Signature>) -> P<Type> | exports.go:235 | Checker
get_return_type_of_single_non_generic_signature | pub(crate) fn get_return_type_of_single_non_generic_signature(&mut self, func_type: P<Type>, kind: SignatureKind) -> Option<P<Type>> | checker.go:7559 | Checker
get_return_type_of_single_non_generic_signature_of_call_chain | pub(crate) fn get_return_type_of_single_non_generic_signature_of_call_chain(&mut self, expr: P<Node>) -> Option<P<Type>> | checker.go:7567 | Checker
get_root_symbols | pub fn get_root_symbols(&mut self, symbol: P<Symbol>) -> Vec<P<Symbol>> | services.go:403 | Checker
get_selected_modifier_flags | pub(crate) fn get_selected_modifier_flags(node: P<Node>, flags: ModifierFlags) -> ModifierFlags | utilities.go:63 | -
get_set_accessor_value_parameter | pub fn get_set_accessor_value_parameter(accessor: P<Node>) -> Option<P<Node>> | utilities.go:1914 | -
get_shorthand_assignment_value_symbol | pub fn get_shorthand_assignment_value_symbol(&mut self, location: Option<P<Node>>) -> Option<P<Symbol>> | services.go:495 | Checker
get_siblings_of_context | pub(crate) fn get_siblings_of_context(&mut self, context: P<WideningContext>) -> Vec<P<Type>> | checker.go:18821 | Checker
get_signature_from_declaration | pub(crate) fn get_signature_from_declaration(&mut self, declaration: P<Node>) -> P<Signature> | checker.go:20177 | Checker
get_signature_from_declaration_exported | pub fn get_signature_from_declaration_exported(&mut self, node: P<Node>) -> P<Signature> | services.go:1120 | Checker
get_signature_instantiation | pub(crate) fn get_signature_instantiation(&mut self, sig: P<Signature>, type_arguments: &[P<Type>], is_java_script: bool, inferred_type_parameters: &[P<Type>]) -> P<Signature> | checker.go:19634 | Checker
get_signature_instantiation_without_filling_in_type_arguments | pub(crate) fn get_signature_instantiation_without_filling_in_type_arguments(&mut self, sig: P<Signature>, type_arguments: &[P<Type>]) -> P<Signature> | checker.go:19659 | Checker
get_signature_of_full_signature_type | pub(crate) fn get_signature_of_full_signature_type(&mut self, node: P<Node>) -> Option<P<Signature>> | checker.go:20413 | Checker
get_signatures_of_structured_type | pub(crate) fn get_signatures_of_structured_type(&mut self, t: P<Type>, kind: SignatureKind) -> &'static [P<Signature>] | checker.go:19307 | Checker
get_signatures_of_symbol | pub(crate) fn get_signatures_of_symbol(&mut self, symbol: Option<P<Symbol>>) -> Vec<P<Signature>> | checker.go:20147 | Checker
get_signatures_of_type | pub fn get_signatures_of_type(&mut self, t: P<Type>, kind: SignatureKind) -> &'static [P<Signature>] | checker.go:19303 | Checker
get_signatures_of_type_exported | pub fn get_signatures_of_type_exported(&mut self, t: P<Type>, kind: SignatureKind) -> &'static [P<Signature>] | exports.go:175 | Checker
get_simplified_conditional_type | pub(crate) fn get_simplified_conditional_type(&mut self, t: P<Type>, writing: bool) -> P<Type> | checker.go:28476 | Checker
get_simplified_indexed_access_type | pub(crate) fn get_simplified_indexed_access_type(&mut self, t: P<Type>, writing: bool) -> P<Type> | checker.go:28385 | Checker
get_simplified_indexed_access_type_worker | pub(crate) fn get_simplified_indexed_access_type_worker(&mut self, t: P<Type>, writing: bool) -> P<Type> | checker.go:28400 | Checker
get_simplified_type | pub(crate) fn get_simplified_type(&mut self, t: P<Type>, writing: bool) -> P<Type> | checker.go:28372 | Checker
get_simplified_type_or_constraint | pub(crate) fn get_simplified_type_or_constraint(&mut self, t: P<Type>) -> Option<P<Type>> | checker.go:28503 | Checker
get_single_base_for_non_augmenting_subtype | pub(crate) fn get_single_base_for_non_augmenting_subtype(&mut self, t: P<Type>) -> Option<P<Type>> | checker.go:28557 | Checker
get_single_call_or_construct_signature | pub(crate) fn get_single_call_or_construct_signature(&mut self, t: P<Type>) -> Option<P<Signature>> | checker.go:19686 | Checker
get_single_call_signature | pub(crate) fn get_single_call_signature(&mut self, t: P<Type>) -> Option<P<Signature>> | checker.go:19682 | Checker
get_single_common_supertype | pub(crate) fn get_single_common_supertype(&mut self, types: &[P<Type>]) -> Option<P<Type>> | inference.go:1558 | Checker
get_single_signature | pub(crate) fn get_single_signature(&mut self, t: P<Type>, kind: SignatureKind, allow_members: bool) -> Option<P<Signature>> | checker.go:19694 | Checker
get_single_type_variable_from_intersection_types | pub(crate) fn get_single_type_variable_from_intersection_types(n: P<InferenceState>, types: &[P<Type>]) -> Option<P<Type>> | inference.go:532 | -
get_single_variable_of_variable_statement | pub fn get_single_variable_of_variable_statement(node: P<Node>) -> Option<P<Node>> | utilities.go:154 | -
get_sort_order_flags | pub(crate) fn get_sort_order_flags(t: P<Type>) -> u32 | utilities.go:624 | -
get_source_file_for_resolved_module | fn get_source_file_for_resolved_module(&mut self, file_name: &'static str) -> Option<P<SourceFile>> | rust:checker_08.rs:172 | Checker
get_specifier_for_module_symbol | pub(crate) fn get_specifier_for_module_symbol(&self, c: &mut Checker, symbol: P<Symbol>, override_import_mode: ModuleKind) -> moduleSpecifierResult | nodebuilderimpl.go:1249 | NodeBuilderImpl
get_spelling_suggestion_for_name | pub(crate) fn get_spelling_suggestion_for_name(&mut self, name: &str, symbols: &[P<Symbol>], meaning: SymbolFlags) -> Option<P<Symbol>> | checker.go:1841 | Checker
get_spread_argument_index | pub(crate) fn get_spread_argument_index(args: &[P<Node>]) -> Option<usize> | checker.go:30597 | Checker
get_spread_argument_type | pub(crate) fn get_spread_argument_type(&mut self, args: &[P<Node>], index: usize, arg_count: usize, rest_type: P<Type>, context: Option<P<InferenceContext>>, check_mode: CheckMode) -> P<Type> | checker.go:29989 | Checker
get_spread_indices | pub(crate) fn get_spread_indices(&mut self, node: P<Node>) -> (Option<usize>, Option<usize>) | checker.go:30612 | Checker
get_spread_symbol | pub(crate) fn get_spread_symbol(&mut self, prop: P<Symbol>, readonly: bool) -> P<Symbol> | checker.go:13803 | Checker
get_spread_type | pub(crate) fn get_spread_type(&mut self, left: P<Type>, right: P<Type>, symbol: Option<P<Symbol>>, object_flags: ObjectFlags, readonly: bool) -> P<Type> | checker.go:13605 | Checker
get_start_element_count | pub(crate) fn get_start_element_count(t: &'static TupleType, flags: ElementFlags) -> usize | checker.go:23906 | -
get_static_type_of_referenced_jsx_constructor | pub(crate) fn get_static_type_of_referenced_jsx_constructor(&mut self, context: P<Node>) -> P<Type> | jsx.go:1114 | Checker
get_string_index_type | pub fn get_string_index_type(&mut self, t: P<Type>) -> Option<P<Type>> | services.go:249 | Checker
get_string_like_type_for_type | pub(crate) fn get_string_like_type_for_type(&mut self, t: P<Type>) -> P<Type> | relater.go:2502 | Checker
get_string_literal_type | pub(crate) fn get_string_literal_type(&mut self, value: &str) -> P<Type> | checker.go:25775 | Checker
get_string_literal_value | pub(crate) fn get_string_literal_value(t: P<Type>) -> &'static str | checker.go:25816 | -
get_string_mapping_type | pub(crate) fn get_string_mapping_type(&mut self, symbol: P<Symbol>, t: P<Type>) -> P<Type> | checker.go:29712 | Checker
get_string_mapping_type_for_generic_type | pub(crate) fn get_string_mapping_type_for_generic_type(&mut self, symbol: P<Symbol>, t: P<Type>) -> P<Type> | checker.go:29765 | Checker
get_string_type | pub fn get_string_type(&self) -> P<Type> | exports.go:8 | Checker
get_substitution_intersection | pub(crate) fn get_substitution_intersection(&mut self, t: P<Type>) -> P<Type> | checker.go:27297 | Checker
get_substitution_type | pub(crate) fn get_substitution_type(&mut self, base_type: P<Type>, constraint: P<Type>) -> P<Type> | checker.go:27881 | Checker
get_suggested_boolean_operator | pub(crate) fn get_suggested_boolean_operator(operator: Kind) -> Kind | checker.go:12995 | Checker
get_suggested_import_extension | pub(crate) fn get_suggested_import_extension(&self, extensionless_import_path: &str) -> String | checker.go:15775 | Checker
get_suggested_import_source | pub(crate) fn get_suggested_import_source(&self, module_reference: &str, ts_extension: &str, mode: ModuleKind) -> String | checker.go:15752 | Checker
get_suggested_lib_for_non_existent_name | pub(crate) fn get_suggested_lib_for_non_existent_name(name: &str) -> String | checker.go:1774 | Checker
get_suggested_lib_for_non_existent_property | pub(crate) fn get_suggested_lib_for_non_existent_property(&mut self, missing_property: &str, containing_type: P<Type>) -> String | checker.go:11794 | Checker
get_suggested_symbol_for_nonexistent_class_member | pub(crate) fn get_suggested_symbol_for_nonexistent_class_member(&mut self, name: &str, base_type: P<Type>) -> Option<P<Symbol>> | checker.go:4873 | Checker
get_suggested_symbol_for_nonexistent_jsx_attribute | pub(crate) fn get_suggested_symbol_for_nonexistent_jsx_attribute(&mut self, name: &str, containing_type: P<Type>) -> Option<P<Symbol>> | jsx.go:485 | Checker
get_suggested_symbol_for_nonexistent_module | pub(crate) fn get_suggested_symbol_for_nonexistent_module(&mut self, name: P<Node>, target_module: P<Symbol>) -> Option<P<Symbol>> | checker.go:16232 | Checker
get_suggested_symbol_for_nonexistent_property | pub(crate) fn get_suggested_symbol_for_nonexistent_property(&mut self, name: P<Node>, containing_type: P<Type>) -> Option<P<Symbol>> | checker.go:11809 | Checker
get_suggested_symbol_for_nonexistent_symbol | pub(crate) fn get_suggested_symbol_for_nonexistent_symbol(&mut self, location: Option<P<Node>>, outer_name: &str, meaning: SymbolFlags) -> Option<P<Symbol>> | checker.go:1782 | Checker
get_suggested_type_for_nonexistent_string_literal_type | pub(crate) fn get_suggested_type_for_nonexistent_string_literal_type(&mut self, source: P<Type>, target: P<Type>) -> Option<P<Type>> | checker.go:27722 | Checker
get_suggestion_diagnostics | pub fn get_suggestion_diagnostics(&mut self, ctx: &Context, source_file: P<SourceFile>) -> Vec<P<Diagnostic>> | checker.go:14190 | Checker
get_suggestion_for_nonexistent_index_signature | pub(crate) fn get_suggestion_for_nonexistent_index_signature(&mut self, object_type: P<Type>, expr: P<Node>, keyed_type: P<Type>) -> String | checker.go:27701 | Checker
get_suggestion_for_nonexistent_property | pub(crate) fn get_suggestion_for_nonexistent_property(&mut self, name: &str, containing_type: P<Type>) -> String | checker.go:27693 | Checker
get_suggestion_for_symbol_name_lookup | pub(crate) fn get_suggestion_for_symbol_name_lookup(&mut self, symbols: Option<P<SymbolTable>>, name: &str, meaning: SymbolFlags) -> Option<P<Symbol>> | checker.go:1816 | Checker
get_super_container | pub(crate) fn get_super_container(node: P<Node>, stop_on_functions: bool) -> Option<P<Node>> | utilities.go:1232 | -
get_switch_clause_type_of_witnesses | pub(crate) fn get_switch_clause_type_of_witnesses(&mut self, node: P<Node>) -> Option<&'static [&'static str]> | flow.go:1989 | Checker
get_switch_clause_types | pub(crate) fn get_switch_clause_types(&mut self, node: P<Node>) -> Vec<P<Type>> | flow.go:2026 | Checker
get_symbol | pub(crate) fn get_symbol(&mut self, symbols: Option<P<SymbolTable>>, name: &str, meaning: SymbolFlags) -> Option<P<Symbol>> | checker.go:2217 | Checker
get_symbol_at_location | pub(crate) fn get_symbol_at_location(&mut self, node: P<Node>, ignore_errors: bool) -> Option<P<Symbol>> | checker.go:32087 | Checker
get_symbol_at_location_exported | pub fn get_symbol_at_location_exported(&mut self, node: P<Node>) -> Option<P<Symbol>> | checker.go:32074 | Checker
get_symbol_chain | pub(crate) fn get_symbol_chain(&self, c: &mut Checker, symbol: P<Symbol>, meaning: SymbolFlags, end_of_chain: bool, yield_module_symbol: bool) -> Vec<P<Symbol>> | nodebuilderimpl.go:1087 | NodeBuilderImpl
get_symbol_flags | pub fn get_symbol_flags(&mut self, symbol: P<Symbol>) -> SymbolFlags | checker.go:16686 | Checker
get_symbol_flags_ex | pub(crate) fn get_symbol_flags_ex(&mut self, symbol: P<Symbol>, exclude_type_only_meanings: bool, exclude_local_meanings: bool) -> SymbolFlags | checker.go:16690 | Checker
get_symbol_flags_exported | pub fn get_symbol_flags_exported(&mut self, symbol: P<Symbol>) -> SymbolFlags | exports.go:300 | Checker
get_symbol_for_private_identifier_expression | pub(crate) fn get_symbol_for_private_identifier_expression(&mut self, node: P<Node>) -> Option<P<Symbol>> | checker.go:8018 | Checker
get_symbol_from_type_reference | pub(crate) fn get_symbol_from_type_reference(&mut self, node: P<Node>) -> P<Symbol> | checker.go:23538 | Checker
get_symbol_has_instance_method_of_object_type | pub(crate) fn get_symbol_has_instance_method_of_object_type(&mut self, t: P<Type>) -> Option<P<Type>> | flow.go:2093 | Checker
get_symbol_if_same_reference | pub(crate) fn get_symbol_if_same_reference(&mut self, s1: P<Symbol>, s2: P<Symbol>) -> Option<P<Symbol>> | checker.go:14605 | Checker
get_symbol_of_declaration | pub(crate) fn get_symbol_of_declaration(&mut self, node: P<Node>) -> Option<P<Symbol>> | checker.go:14619 | Checker
get_symbol_of_name_or_property_access_expression | pub(crate) fn get_symbol_of_name_or_property_access_expression(&mut self, name: P<Node>) -> Option<P<Symbol>> | checker.go:32273 | Checker
get_symbol_of_node | pub(crate) fn get_symbol_of_node(&mut self, node: P<Node>) -> Option<P<Symbol>> | checker.go:14629 | Checker
get_symbol_of_part_of_right_hand_side_of_import_equals | pub(crate) fn get_symbol_of_part_of_right_hand_side_of_import_equals(&mut self, entity_name: P<Node>) -> Option<P<Symbol>> | checker.go:14703 | Checker
get_symbol_path | pub(crate) fn get_symbol_path(symbol: P<Symbol>) -> String | checker.go:23600 | -
get_symbol_table_aliases | pub(crate) fn get_symbol_table_aliases(&mut self, symbols: Option<P<SymbolTable>>, table_id: symbolTableID) -> Vec<P<Symbol>> | symbolaccessibility.go:505 | Checker
get_symbol_target_for_alias_lookup | fn get_symbol_target_for_alias_lookup(&mut self, s: P<Symbol>) -> P<Symbol> | rust:printer.rs:963 | Checker
get_symbols_in_scope | pub(crate) fn get_symbols_in_scope(&mut self, location: P<Node>, meaning: SymbolFlags) -> Vec<P<Symbol>> | services.go:21 | Checker
get_symbols_in_scope_exported | pub fn get_symbols_in_scope_exported(&mut self, location: P<Node>, meaning: SymbolFlags) -> Vec<P<Symbol>> | services.go:17 | Checker
get_symbols_of_parameter_property_declaration | pub fn get_symbols_of_parameter_property_declaration(&mut self, parameter: P<Node> /*ParameterPropertyDeclaration*/, parameter_name: &str) -> (P<Symbol>, P<Symbol>) | services.go:508 | Checker
get_syntactic_nullishness_semantics | pub(crate) fn get_syntactic_nullishness_semantics(&mut self, node: P<Node>) -> PredicateSemantics | checker.go:13156 | Checker
get_syntactic_truthy_semantics | pub(crate) fn get_syntactic_truthy_semantics(&mut self, node: P<Node>) -> PredicateSemantics | checker.go:13094 | Checker
get_synthetic_element_access | pub(crate) fn get_synthetic_element_access(&mut self, node: P<Node>) -> Option<P<Node>> | checker.go:18197 | Checker
get_tail_recursion_root | pub(crate) fn get_tail_recursion_root(&mut self, new_type: P<Type>, new_mapper: Option<P<TypeMapper>>) -> (Option<P<ConditionalRoot>>, Option<P<TypeMapper>>) | checker.go:24920 | Checker
get_target_of_access_expression | pub(crate) fn get_target_of_access_expression(&mut self, node: P<Node>) -> Option<P<Symbol>> | checker.go:15263 | Checker
get_target_of_alias_declaration | pub(crate) fn get_target_of_alias_declaration(&mut self, node: Option<P<Node>>) -> Option<P<Symbol>> | checker.go:16059 | Checker
get_target_of_alias_like_expression | pub(crate) fn get_target_of_alias_like_expression(&mut self, expression: P<Node>) -> Option<P<Symbol>> | checker.go:15239 | Checker
get_target_of_binary_expression | pub(crate) fn get_target_of_binary_expression(&mut self, node: P<Node>) -> Option<P<Symbol>> | checker.go:15233 | Checker
get_target_of_export_assignment | pub(crate) fn get_target_of_export_assignment(&mut self, node: P<Node>) -> Option<P<Symbol>> | checker.go:15219 | Checker
get_target_of_export_specifier | pub(crate) fn get_target_of_export_specifier(&mut self, node: P<Node>, meaning: SymbolFlags, dont_resolve_alias: bool) -> Option<P<Symbol>> | checker.go:15194 | Checker
get_target_of_import_clause | pub(crate) fn get_target_of_import_clause(&mut self, node: P<Node>) -> Option<P<Symbol>> | checker.go:14757 | Checker
get_target_of_import_equals_declaration | pub(crate) fn get_target_of_import_equals_declaration(&mut self, node: P<Node>) -> Option<P<Symbol>> | checker.go:14668 | Checker
get_target_of_import_specifier | pub(crate) fn get_target_of_import_specifier(&mut self, node: P<Node>) -> Option<P<Symbol>> | checker.go:14885 | Checker
get_target_of_module_default | pub(crate) fn get_target_of_module_default(&mut self, module_symbol: P<Symbol>, node: P<Node>, dont_resolve_alias: bool) -> Option<P<Symbol>> | checker.go:14765 | Checker
get_target_of_namespace_export | pub(crate) fn get_target_of_namespace_export(&mut self, node: P<Node>) -> Option<P<Symbol>> | checker.go:14874 | Checker
get_target_of_namespace_export_declaration | pub(crate) fn get_target_of_namespace_export_declaration(&mut self, node: P<Node>) -> Option<P<Symbol>> | checker.go:15254 | Checker
get_target_of_namespace_import | pub(crate) fn get_target_of_namespace_import(&mut self, node: P<Node>) -> Option<P<Symbol>> | checker.go:14866 | Checker
get_target_symbol | pub(crate) fn get_target_symbol(&mut self, s: P<Symbol>) -> Option<P<Symbol>> | checker.go:22024 | Checker
get_target_symbol_exported | pub fn get_target_symbol_exported(&mut self, symbol: P<Symbol>) -> Option<P<Symbol>> | exports.go:115 | Checker
get_target_type | pub(crate) fn get_target_type(t: P<Type>) -> Option<P<Type>> | checker.go:19907 | -
get_target_type | pub(crate) fn get_target_type(t: P<Type>) -> Option<P<Type>> | checker.go:31973 | Checker
get_template_literal_type | pub(crate) fn get_template_literal_type(&mut self, texts: &[&str], types: &[P<Type>]) -> P<Type> | checker.go:29623 | Checker
get_template_literal_type_worker | fn get_template_literal_type_worker(&mut self, texts: &[&str], types: &[P<Type>], sb: &mut String) -> P<Type> | rust:checker_14.rs:1511 | Checker
get_template_type_from_mapped_type | pub(crate) fn get_template_type_from_mapped_type(&mut self, t: P<Type>) -> P<Type> | checker.go:23122 | Checker
get_template_type_key | pub(crate) fn get_template_type_key(texts: &[&str], types: &[P<Type>]) -> CacheHashKey | checker.go:17929 | -
get_this_argument_of_call | pub(crate) fn get_this_argument_of_call(&self, node: P<Node>) -> Option<P<Node>> | checker.go:9537 | Checker
get_this_argument_type | pub(crate) fn get_this_argument_type(&mut self, node: Option<P<Node>>) -> P<Type> | checker.go:9559 | Checker
get_this_container | pub(crate) fn get_this_container(node: P<Node>, include_arrow_functions: bool, include_class_computed_property_name: bool) -> Option<P<Node>> | checker.go:12391 | Checker
get_this_parameter_from_node_context | pub(crate) fn get_this_parameter_from_node_context(node: P<Node>) -> Option<P<Node>> | checker.go:12216 | -
get_this_type | pub(crate) fn get_this_type(&mut self, node: P<Node>) -> P<Type> | checker.go:23333 | Checker
get_this_type_argument | pub(crate) fn get_this_type_argument(&mut self, t: P<Type>) -> Option<P<Type>> | checker.go:32568 | Checker
get_this_type_from_contextual_type | pub(crate) fn get_this_type_from_contextual_type(&mut self, t: P<Type>) -> Option<P<Type>> | checker.go:32552 | Checker
get_this_type_of_object_literal_from_contextual_type | pub(crate) fn get_this_type_of_object_literal_from_contextual_type(&mut self, containing_literal: P<Node>, contextual_type: Option<P<Type>>) -> Option<P<Type>> | checker.go:32535 | Checker
get_this_type_of_signature | pub(crate) fn get_this_type_of_signature(&mut self, signature: P<Signature>) -> Option<P<Type>> | relater.go:1947 | Checker
get_topmost_indexed_access_type | pub(crate) fn get_topmost_indexed_access_type(node: P<Node>) -> P<Node> | nodebuilderimpl.go:745 | -
get_total_fixed_element_count | pub(crate) fn get_total_fixed_element_count(t: &'static TupleType) -> usize | checker.go:23925 | -
get_true_type_from_conditional_type | pub(crate) fn get_true_type_from_conditional_type(&mut self, t: P<Type>) -> P<Type> | checker.go:25009 | Checker
get_true_type_of_conditional_type | pub fn get_true_type_of_conditional_type(&mut self, t: P<Type>) -> P<Type> | exports.go:195 | Checker
get_tuple_base_type | pub(crate) fn get_tuple_base_type(&mut self, t: P<Type>) -> P<Type> | checker.go:19547 | Checker
get_tuple_element_flags | pub(crate) fn get_tuple_element_flags(node: P<Node>) -> ElementFlags | checker.go:25179 | Checker
get_tuple_element_info | pub(crate) fn get_tuple_element_info(node: P<Node>) -> TupleElementInfo | checker.go:25198 | Checker
get_tuple_element_label | pub(crate) fn get_tuple_element_label(element_info: TupleElementInfo, rest_symbol: Option<P<Symbol>>, index: usize) -> String | relater.go:1976 | Checker
get_tuple_element_label_from_binding_element | pub(crate) fn get_tuple_element_label_from_binding_element(node: P<Node>, index: usize, element_flags: ElementFlags) -> String | relater.go:1992 | Checker
get_tuple_element_type | pub(crate) fn get_tuple_element_type(&mut self, t: P<Type>, index: usize) -> Option<P<Type>> | checker.go:24025 | Checker
get_tuple_element_type_out_of_start_count | pub(crate) fn get_tuple_element_type_out_of_start_count(&mut self, t: P<Type>, index: Number, undefined_like_type: Option<P<Type>>) -> P<Type> | checker.go:25325 | Checker
get_tuple_key | pub(crate) fn get_tuple_key(element_infos: &[TupleElementInfo], readonly: bool) -> CacheHashKey | checker.go:17883 | -
get_tuple_target_type | pub(crate) fn get_tuple_target_type(&mut self, element_infos: &[TupleElementInfo], readonly: bool) -> P<Type> | checker.go:25221 | Checker
get_type | pub(crate) fn get_type(&self, type_kind: IterationTypeKind) -> Option<P<Type>> | checker.go:6578 | IterationTypes
get_type_alias_for_type_literal | pub(crate) fn get_type_alias_for_type_literal(c: &mut Checker, t: P<Type>) -> Option<P<Symbol>> | nodebuilderimpl.go:2842 | -
get_type_alias_instantiation | pub(crate) fn get_type_alias_instantiation(&mut self, symbol: P<Symbol>, type_arguments: &[P<Type>], alias: Option<P<TypeAlias>>) -> P<Type> | checker.go:24102 | Checker
get_type_alias_instantiation_key | pub(crate) fn get_type_alias_instantiation_key(type_arguments: &[P<Type>], alias: Option<P<TypeAlias>>) -> CacheHashKey | checker.go:17906 | -
get_type_alias_type_parameters | pub fn get_type_alias_type_parameters(&mut self, symbol: P<Symbol>) -> Vec<P<Type>> | checker.go:1212 | Checker
get_type_argument_arity_error | pub(crate) fn get_type_argument_arity_error(node: P<Node>, signatures: &[P<Signature>], type_arguments: &[P<Node>], head_message: Option<&'static Message>) -> P<Diagnostic> | checker.go:10045 | Checker
get_type_argument_constraint | pub(crate) fn get_type_argument_constraint(&mut self, node: P<Node>) -> Option<P<Type>> | services.go:742 | Checker
get_type_argument_constraint_exported | pub fn get_type_argument_constraint_exported(&mut self, node: P<Node>) -> Option<P<Type>> | services.go:700 | Checker
get_type_arguments | pub fn get_type_arguments(&mut self, t: P<Type>) -> &'static [P<Type>] | checker.go:22289 | Checker
get_type_arguments_exported | pub fn get_type_arguments_exported(&mut self, t: P<Type>) -> &'static [P<Type>] | exports.go:334 | Checker
get_type_arguments_for_alias_symbol | pub(crate) fn get_type_arguments_for_alias_symbol(&mut self, symbol: Option<P<Symbol>>) -> Vec<P<Type>> | checker.go:24191 | Checker
get_type_arguments_from_node | pub(crate) fn get_type_arguments_from_node(&mut self, node: P<Node>) -> Vec<P<Type>> | checker.go:23677 | Checker
get_type_arguments_from_nodes | pub(crate) fn get_type_arguments_from_nodes(&mut self, type_argument_nodes: &[P<Node>], type_parameters: &[P<Type>]) -> Vec<P<Type>> | checker.go:9749 | Checker
get_type_at_flow_array_mutation | pub(crate) fn get_type_at_flow_array_mutation(&mut self, f: P<FlowState>, flow: P<FlowNode>) -> FlowType | flow.go:1404 | Checker
get_type_at_flow_assignment | pub(crate) fn get_type_at_flow_assignment(&mut self, f: P<FlowState>, flow: P<FlowNode>) -> FlowType | flow.go:220 | Checker
get_type_at_flow_branch_label | pub(crate) fn get_type_at_flow_branch_label(&mut self, f: P<FlowState>, _flow: P<FlowNode>, antecedents: P<FlowList>) -> FlowType | flow.go:1253 | Checker
get_type_at_flow_call | pub(crate) fn get_type_at_flow_call(&mut self, f: P<FlowState>, flow: P<FlowNode>) -> FlowType | flow.go:288 | Checker
get_type_at_flow_condition | pub(crate) fn get_type_at_flow_condition(&mut self, f: P<FlowState>, flow: P<FlowNode>) -> FlowType | flow.go:354 | Checker
get_type_at_flow_loop_label | pub(crate) fn get_type_at_flow_loop_label(&mut self, f: P<FlowState>, flow: P<FlowNode>) -> FlowType | flow.go:1325 | Checker
get_type_at_flow_node | pub(crate) fn get_type_at_flow_node(&mut self, f: P<FlowState>, flow: P<FlowNode>) -> FlowType | flow.go:117 | Checker
get_type_at_flow_node_step | fn get_type_at_flow_node_step(&mut self, f: P<FlowState>, flow: P<FlowNode>, flags: FlowFlags) -> FlowStep | rust:flow.rs:345 | Checker
get_type_at_location | pub fn get_type_at_location(&mut self, node: P<Node>) -> P<Type> | checker.go:32652 | Checker
get_type_at_position | pub(crate) fn get_type_at_position(&mut self, signature: P<Signature>, pos: usize) -> P<Type> | relater.go:1790 | Checker
get_type_at_position_exported | pub fn get_type_at_position_exported(&mut self, s: P<Signature>, pos: usize) -> P<Type> | services.go:936 | Checker
get_type_at_switch_clause | pub(crate) fn get_type_at_switch_clause(&mut self, f: P<FlowState>, flow: P<FlowNode>) -> FlowType | flow.go:1059 | Checker
get_type_depth | pub(crate) fn get_type_depth(c: &mut Checker, t: P<Type>, max_depth: usize) -> usize | inference.go:423 | -
get_type_facts | pub(crate) fn get_type_facts(&mut self, t: P<Type>, mask: TypeFacts) -> TypeFacts | checker.go:31463 | Checker
get_type_facts_worker | pub(crate) fn get_type_facts_worker(&mut self, t: P<Type>, caller_only_needs: TypeFacts) -> TypeFacts | checker.go:31471 | Checker
get_type_for_binding_element | pub(crate) fn get_type_for_binding_element(&mut self, declaration: P<Node>) -> Option<P<Type>> | checker.go:18024 | Checker
get_type_for_binding_element_parent | pub(crate) fn get_type_for_binding_element_parent(&mut self, node: P<Node>, check_mode: CheckMode) -> Option<P<Type>> | checker.go:18035 | Checker
get_type_for_variable_like_declaration | pub(crate) fn get_type_for_variable_like_declaration(&mut self, declaration: P<Node>, include_optionality: bool, check_mode: CheckMode) -> Option<P<Type>> | checker.go:16975 | Checker
get_type_from_array_binding_pattern | pub(crate) fn get_type_from_array_binding_pattern(&mut self, pattern: P<Node>, include_pattern_in_type: bool, report_errors: bool) -> P<Type> | checker.go:18297 | Checker
get_type_from_array_or_tuple_type_node | pub(crate) fn get_type_from_array_or_tuple_type_node(&mut self, node: P<Node>) -> P<Type> | checker.go:24585 | Checker
get_type_from_binding_element | pub(crate) fn get_type_from_binding_element(&mut self, element: P<Node>, include_pattern_in_type: bool, report_errors: bool) -> P<Type> | checker.go:18346 | Checker
get_type_from_binding_pattern | pub(crate) fn get_type_from_binding_pattern(&mut self, pattern: P<Node>, include_pattern_in_type: bool, report_errors: bool) -> P<Type> | checker.go:18244 | Checker
get_type_from_class_or_interface_reference | pub(crate) fn get_type_from_class_or_interface_reference(&mut self, node: P<Node>, symbol: P<Symbol>) -> P<Type> | checker.go:23630 | Checker
get_type_from_conditional_type_node | pub(crate) fn get_type_from_conditional_type_node(&mut self, node: P<Node>) -> P<Type> | checker.go:24739 | Checker
get_type_from_import_attributes | pub(crate) fn get_type_from_import_attributes(&mut self, node: Option<P<Node>>) -> Option<P<Type>> | checker.go:5569 | Checker
get_type_from_import_type_node | pub(crate) fn get_type_from_import_type_node(&mut self, node: P<Node>) -> P<Type> | checker.go:25045 | Checker
get_type_from_index_infos_of_contextual_type | pub(crate) fn get_type_from_index_infos_of_contextual_type(&mut self, t: P<Type>, name: &str, name_type: Option<P<Type>>) -> Option<P<Type>> | checker.go:31135 | Checker
get_type_from_indexed_access_type_node | pub(crate) fn get_type_from_indexed_access_type_node(&mut self, node: P<Node>) -> P<Type> | checker.go:23374 | Checker
get_type_from_infer_type_node | pub(crate) fn get_type_from_infer_type_node(&mut self, node: P<Node>) -> P<Type> | checker.go:25037 | Checker
get_type_from_inference | pub(crate) fn get_type_from_inference(&mut self, inference: P<InferenceInfo>) -> Option<P<Type>> | inference.go:1509 | Checker
get_type_from_intersection_type_node | pub(crate) fn get_type_from_intersection_type_node(&mut self, node: P<Node>) -> P<Type> | checker.go:24688 | Checker
get_type_from_literal_type_node | pub(crate) fn get_type_from_literal_type_node(&mut self, node: P<Node>) -> P<Type> | checker.go:23347 | Checker
get_type_from_mapped_type_node | pub(crate) fn get_type_from_mapped_type_node(&mut self, node: P<Node>) -> P<Type> | checker.go:24725 | Checker
get_type_from_named_tuple_type_node | pub(crate) fn get_type_from_named_tuple_type_node(&mut self, node: P<Node>) -> P<Type> | checker.go:24634 | Checker
get_type_from_object_binding_pattern | pub(crate) fn get_type_from_object_binding_pattern(&mut self, pattern: P<Node>, include_pattern_in_type: bool, report_errors: bool) -> P<Type> | checker.go:18261 | Checker
get_type_from_optional_type_node | pub(crate) fn get_type_from_optional_type_node(&mut self, node: P<Node>) -> P<Type> | checker.go:24675 | Checker
get_type_from_property_descriptor | pub(crate) fn get_type_from_property_descriptor(&mut self, node: P<Node>) -> P<Type> | checker.go:18510 | Checker
get_type_from_rest_type_node | pub(crate) fn get_type_from_rest_type_node(&mut self, node: P<Node>) -> P<Type> | checker.go:24646 | Checker
get_type_from_template_type_node | pub(crate) fn get_type_from_template_type_node(&mut self, node: P<Node>) -> P<Type> | checker.go:24709 | Checker
get_type_from_this_type_node | pub(crate) fn get_type_from_this_type_node(&mut self, node: P<Node>) -> P<Type> | checker.go:23325 | Checker
get_type_from_type_alias_reference | pub(crate) fn get_type_from_type_alias_reference(&mut self, node: P<Node>, symbol: P<Symbol>) -> P<Type> | checker.go:24041 | Checker
get_type_from_type_literal_or_function_or_constructor_type_node | pub(crate) fn get_type_from_type_literal_or_function_or_constructor_type_node(&mut self, node: P<Node>) -> P<Type> | checker.go:23358 | Checker
get_type_from_type_node | pub fn get_type_from_type_node(&mut self, node: P<Node>) -> P<Type> | checker.go:23232 | Checker
get_type_from_type_node | pub(crate) fn get_type_from_type_node(&self, c: &mut Checker, node: P<Node>, no_mapped_types: bool) -> Option<P<Type>> | nodebuilderimpl.go:2978 | NodeBuilderImpl
get_type_from_type_node_exported | pub fn get_type_from_type_node_exported(&mut self, node: P<Node>) -> P<Type> | exports.go:131 | Checker
get_type_from_type_node_worker | pub(crate) fn get_type_from_type_node_worker(&mut self, node: P<Node>) -> P<Type> | checker.go:23236 | Checker
get_type_from_type_operator_node | pub(crate) fn get_type_from_type_operator_node(&mut self, node: P<Node>) -> P<Type> | checker.go:23385 | Checker
get_type_from_type_query_node | pub(crate) fn get_type_from_type_query_node(&mut self, node: P<Node>) -> P<Type> | checker.go:24572 | Checker
get_type_from_type_reference | pub(crate) fn get_type_from_type_reference(&mut self, node: P<Node>) -> P<Type> | checker.go:23428 | Checker
get_type_from_union_type_node | pub(crate) fn get_type_from_union_type_node(&mut self, node: P<Node>) -> P<Type> | checker.go:24679 | Checker
get_type_instantiation_key | pub(crate) fn get_type_instantiation_key(type_arguments: &[P<Type>], alias: AliasArg<'_>, single_signature: bool) -> CacheHashKey | checker.go:17910 | -
get_type_instantiation_key_hashed | fn get_type_instantiation_key_hashed(type_arguments: &[P<Type>], alias: AliasArg<'_>, single_signature: bool) -> CacheHashKey | rust:checker_09.rs:679 | -
get_type_list_depth | pub(crate) fn get_type_list_depth(c: &mut Checker, types: &[P<Type>], max_depth: usize) -> usize | inference.go:440 | -
get_type_list_key | pub(crate) fn get_type_list_key(types: &[P<Type>]) -> CacheHashKey | checker.go:17836 | -
get_type_name_for_error_display | pub(crate) fn get_type_name_for_error_display(&mut self, t: P<Type>) -> String | relater.go:1290 | Checker
get_type_name_symbol | pub(crate) fn get_type_name_symbol(t: P<Type>) -> Option<P<Symbol>> | utilities.go:651 | -
get_type_names_for_error_display | pub(crate) fn get_type_names_for_error_display(&mut self, left: P<Type>, right: P<Type>) -> (String, String) | relater.go:1270 | Checker
get_type_of_accessors | pub(crate) fn get_type_of_accessors(&mut self, symbol: P<Symbol>) -> P<Type> | checker.go:18855 | Checker
get_type_of_alias | pub(crate) fn get_type_of_alias(&mut self, symbol: P<Symbol>) -> P<Type> | checker.go:18942 | Checker
get_type_of_assignment_pattern | pub(crate) fn get_type_of_assignment_pattern(&mut self, expr: P<Node>) -> Option<P<Type>> | services.go:1090 | Checker
get_type_of_concrete_property_of_contextual_type | pub(crate) fn get_type_of_concrete_property_of_contextual_type(&mut self, t: P<Type>, name: &str) -> Option<P<Type>> | checker.go:31127 | Checker
get_type_of_destructured_array_element | pub(crate) fn get_type_of_destructured_array_element(&mut self, t: P<Type>, index: usize) -> P<Type> | flow.go:2327 | Checker
get_type_of_destructured_property | pub(crate) fn get_type_of_destructured_property(&mut self, t: P<Type>, name: P<Node>) -> P<Type> | flow.go:2365 | Checker
get_type_of_destructured_spread_expression | pub(crate) fn get_type_of_destructured_spread_expression(&mut self, t: P<Type>) -> P<Type> | flow.go:2353 | Checker
get_type_of_dotted_name | pub(crate) fn get_type_of_dotted_name(&mut self, node: P<Node>, diagnostic: Option<P<Diagnostic>>) -> Option<P<Type>> | flow.go:2122 | Checker
get_type_of_enum_member | pub(crate) fn get_type_of_enum_member(&mut self, symbol: P<Symbol>) -> P<Type> | checker.go:18847 | Checker
get_type_of_expression | pub(crate) fn get_type_of_expression(&mut self, node: P<Node>) -> P<Type> | checker.go:7509 | Checker
get_type_of_first_parameter_of_signature | pub(crate) fn get_type_of_first_parameter_of_signature(&mut self, signature: P<Signature>) -> P<Type> | checker.go:29471 | Checker
get_type_of_first_parameter_of_signature_with_fallback | pub(crate) fn get_type_of_first_parameter_of_signature_with_fallback(&mut self, signature: P<Signature>, fallback_type: P<Type>) -> P<Type> | checker.go:29475 | Checker
get_type_of_func_class_enum_module | pub(crate) fn get_type_of_func_class_enum_module(&mut self, symbol: P<Symbol>) -> P<Type> | checker.go:17228 | Checker
get_type_of_func_class_enum_module_worker | pub(crate) fn get_type_of_func_class_enum_module_worker(&mut self, symbol: P<Symbol>) -> P<Type> | checker.go:17236 | Checker
get_type_of_initializer | pub(crate) fn get_type_of_initializer(&mut self, node: P<Node>) -> P<Type> | flow.go:2260 | Checker
get_type_of_instantiated_symbol | pub(crate) fn get_type_of_instantiated_symbol(&mut self, symbol: P<Symbol>) -> P<Type> | checker.go:16851 | Checker
get_type_of_mapped_symbol | pub(crate) fn get_type_of_mapped_symbol(&mut self, symbol: P<Symbol>) -> P<Type> | checker.go:21325 | Checker
get_type_of_mapped_symbol_worker | fn get_type_of_mapped_symbol_worker(&mut self, symbol: P<Symbol>) -> P<Type> | rust:checker_10.rs:2336 | Checker
get_type_of_module_declaration_import_attributes | pub(crate) fn get_type_of_module_declaration_import_attributes(&mut self, attributes: Option<P<Node>>) -> P<Type> | checker.go:5330 | Checker
get_type_of_module_import_attributes | pub(crate) fn get_type_of_module_import_attributes(&mut self, symbol: P<Symbol>) -> P<Type> | checker.go:5337 | Checker
get_type_of_node | pub(crate) fn get_type_of_node(&mut self, node: P<Node>) -> P<Type> | checker.go:32423 | Checker
get_type_of_parameter | pub(crate) fn get_type_of_parameter(&mut self, symbol: P<Symbol>) -> P<Type> | checker.go:17366 | Checker
get_type_of_property_in_base_class | pub(crate) fn get_type_of_property_in_base_class(&mut self, property: P<Symbol>) -> Option<P<Type>> | checker.go:11656 | Checker
get_type_of_property_in_type | pub(crate) fn get_type_of_property_in_type(&mut self, t: P<Type>, name: &str) -> P<Type> | relater.go:2837 | Checker
get_type_of_property_in_types | pub(crate) fn get_type_of_property_in_types(&mut self, types: &[P<Type>], name: &str) -> P<Type> | relater.go:2829 | Checker
get_type_of_property_of_contextual_type | pub fn get_type_of_property_of_contextual_type(&mut self, t: P<Type>, name: &str) -> Option<P<Type>> | checker.go:31040 | Checker
get_type_of_property_of_contextual_type_ex | pub(crate) fn get_type_of_property_of_contextual_type_ex(&mut self, t: P<Type>, name: &str, name_type: Option<P<Type>>) -> Option<P<Type>> | checker.go:31044 | Checker
get_type_of_property_of_contextual_type_exported | pub fn get_type_of_property_of_contextual_type_exported(&mut self, t: P<Type>, name: &str) -> Option<P<Type>> | exports.go:163 | Checker
get_type_of_property_of_type | pub fn get_type_of_property_of_type(&mut self, t: P<Type>, name: &str) -> Option<P<Type>> | checker.go:19295 | Checker
get_type_of_property_of_type_exported | pub fn get_type_of_property_of_type_exported(&mut self, t: P<Type>, name: &str) -> Option<P<Type>> | exports.go:264 | Checker
get_type_of_property_or_index_signature_of_type | pub fn get_type_of_property_or_index_signature_of_type(&mut self, t: P<Type>, name: &str) -> Option<P<Type>> | checker.go:29803 | Checker
get_type_of_prototype_property | pub(crate) fn get_type_of_prototype_property(&mut self, prototype: P<Symbol>) -> P<Type> | checker.go:18381 | Checker
get_type_of_reverse_mapped_symbol | pub(crate) fn get_type_of_reverse_mapped_symbol(&mut self, symbol: P<Symbol>) -> P<Type> | inference.go:1145 | Checker
get_type_of_switch_clause | pub(crate) fn get_type_of_switch_clause(&mut self, clause: P<Node>) -> P<Type> | flow.go:2040 | Checker
get_type_of_symbol | pub fn get_type_of_symbol(&mut self, symbol: P<Symbol>) -> P<Type> | checker.go:16816 | Checker
get_type_of_symbol_at_location | pub fn get_type_of_symbol_at_location(&mut self, symbol: P<Symbol>, location: Option<P<Node>>) -> Option<P<Type>> | checker.go:16777 | Checker
get_type_of_symbol_exported | pub fn get_type_of_symbol_exported(&mut self, symbol: P<Symbol>) -> P<Type> | exports.go:183 | Checker
get_type_of_symbol_with_deferred_type | pub(crate) fn get_type_of_symbol_with_deferred_type(&mut self, symbol: P<Symbol>) -> P<Type> | checker.go:16724 | Checker
get_type_of_variable_or_parameter_or_property | pub(crate) fn get_type_of_variable_or_parameter_or_property(&mut self, symbol: P<Symbol>) -> P<Type> | checker.go:16867 | Checker
get_type_of_variable_or_parameter_or_property_worker | pub(crate) fn get_type_of_variable_or_parameter_or_property_worker(&mut self, symbol: P<Symbol>) -> P<Type> | checker.go:16901 | Checker
get_type_only_alias_declaration | pub fn get_type_only_alias_declaration(&mut self, symbol: P<Symbol>) -> Option<P<Node>> | checker.go:2174 | Checker
get_type_only_alias_declaration_ex | pub(crate) fn get_type_only_alias_declaration_ex(&mut self, symbol: P<Symbol>, meaning: SymbolFlags) -> Option<P<Node>> | checker.go:2184 | Checker
get_type_only_alias_declaration_exported | pub fn get_type_only_alias_declaration_exported(&mut self, symbol: P<Symbol>) -> Option<P<Node>> | exports.go:119 | Checker
get_type_only_declaration_of_entity_name | pub(crate) fn get_type_only_declaration_of_entity_name(&mut self, name: P<Node>) -> Option<P<Node>> | checker.go:14750 | Checker
get_type_parameter_at_position | pub fn get_type_parameter_at_position(&mut self, s: P<Signature>, pos: usize) -> P<Type> | services.go:940 | Checker
get_type_parameter_constraint_for_position_across_signatures | pub(crate) fn get_type_parameter_constraint_for_position_across_signatures(&mut self, signatures: &[P<Signature>], position: usize) -> P<Type> | services.go:727 | Checker
get_type_parameter_from_mapped_type | pub(crate) fn get_type_parameter_from_mapped_type(&mut self, t: P<Type>) -> P<Type> | checker.go:23095 | Checker
get_type_parameter_modifiers | pub(crate) fn get_type_parameter_modifiers(tp: P<Type>) -> ModifierFlags | relater.go:1466 | Checker
get_type_parameters_for_mapper | pub(crate) fn get_type_parameters_for_mapper(&mut self, sig: P<Signature>) -> Vec<P<Type>> | checker.go:19677 | Checker
get_type_parameters_for_type_and_symbol | pub(crate) fn get_type_parameters_for_type_and_symbol(&mut self, t: P<Type>, symbol: P<Symbol>) -> Vec<P<Type>> | checker.go:17522 | Checker
get_type_parameters_for_type_reference_or_import | pub(crate) fn get_type_parameters_for_type_reference_or_import(&mut self, node: P<Node>) -> Vec<P<Type>> | checker.go:17511 | Checker
get_type_parameters_from_declaration | pub(crate) fn get_type_parameters_from_declaration(&mut self, declaration: P<Node>) -> Vec<P<Type>> | checker.go:20253 | Checker
get_type_parameters_of_class_or_interface | pub(crate) fn get_type_parameters_of_class_or_interface(c: &mut Checker, symbol: P<Symbol>) -> Vec<P<Type>> | nodebuilderimpl.go:1029 | NodeBuilderImpl
get_type_predicate_argument | pub(crate) fn get_type_predicate_argument(predicate: P<TypePredicate>, call_expression: P<Node>) -> Option<P<Node>> | flow.go:2451 | Checker
get_type_predicate_from_body | pub(crate) fn get_type_predicate_from_body(&mut self, fn_: P<Node>) -> Option<P<TypePredicate>> | checker.go:20876 | Checker
get_type_predicate_of_signature | pub fn get_type_predicate_of_signature(&mut self, sig: P<Signature>) -> Option<P<TypePredicate>> | relater.go:2049 | Checker
get_type_predicate_of_signature_exported | pub fn get_type_predicate_of_signature_exported(&mut self, sig: P<Signature>) -> Option<P<TypePredicate>> | exports.go:215 | Checker
get_type_predicate_parent | pub(crate) fn get_type_predicate_parent(node: P<Node>) -> Option<P<Node>> | checker.go:3147 | Checker
get_type_reference_arity | pub(crate) fn get_type_reference_arity(t: P<Type>) -> usize | checker.go:23938 | Checker
get_type_reference_name | pub(crate) fn get_type_reference_name(node: P<Node>) -> Option<P<Node>> | checker.go:24157 | -
get_type_reference_serialization_kind | pub fn get_type_reference_serialization_kind(&self, c: &mut Checker, type_name: Option<P<Node>>, location: Option<P<Node>>) -> TypeReferenceSerializationKind | emitresolver.go:1165 | EmitResolver
get_type_reference_type | pub(crate) fn get_type_reference_type(&mut self, node: P<Node>, symbol: P<Symbol>) -> P<Type> | checker.go:23607 | Checker
get_type_with_default | pub fn get_type_with_default(&mut self, t: P<Type>, default_expression: Option<P<Node>>) -> P<Type> | flow.go:2389 | Checker
get_type_with_facts | pub(crate) fn get_type_with_facts(&mut self, t: P<Type>, include: TypeFacts) -> P<Type> | checker.go:31639 | Checker
get_type_with_synthetic_default_import_type | pub(crate) fn get_type_with_synthetic_default_import_type(&mut self, t: P<Type>, symbol: P<Symbol>, original_symbol: P<Symbol>, module_specifier: P<Node>) -> P<Type> | checker.go:15969 | Checker
get_type_with_synthetic_default_only | pub(crate) fn get_type_with_synthetic_default_only(&mut self, t: Option<P<Type>>, symbol: P<Symbol>, original_symbol: P<Symbol>, module_specifier: P<Node>, import_attributes_type: Option<P<Type>>) -> Option<P<Type>> | checker.go:15955 | Checker
get_type_with_this_argument | pub(crate) fn get_type_with_this_argument(&mut self, t: P<Type>, this_argument: Option<P<Type>>, need_apparent_type: bool) -> P<Type> | checker.go:19914 | Checker
get_type_without_signatures | pub(crate) fn get_type_without_signatures(&mut self, t: P<Type>) -> P<Type> | checker.go:4571 | Checker
get_unary_result_type | pub(crate) fn get_unary_result_type(&mut self, operand_type: P<Type>) -> P<Type> | checker.go:11123 | Checker
get_undefined_property | pub(crate) fn get_undefined_property(&mut self, prop: P<Symbol>) -> P<Symbol> | checker.go:18837 | Checker
get_undefined_stripped_target_if_needed | pub(crate) fn get_undefined_stripped_target_if_needed(c: &mut Checker, source: P<Type>, target: P<Type>) -> P<Type> | relater.go:2997 | Relater
get_undefined_symbol | pub fn get_undefined_symbol(&self) -> P<Symbol> | exports.go:68 | Checker
get_undefined_type | pub fn get_undefined_type(&self) -> P<Type> | exports.go:24 | Checker
get_uninstantiated_jsx_signatures_of_type | pub(crate) fn get_uninstantiated_jsx_signatures_of_type(&mut self, element_type: P<Type>, caller: P<Node>) -> Vec<P<Signature>> | jsx.go:896 | Checker
get_uninstantiated_signatures | pub(crate) fn get_uninstantiated_signatures(&mut self, node: P<Node>) -> &'static [P<Signature>] | services.go:708 | Checker
get_union_index_infos | pub(crate) fn get_union_index_infos(&mut self, types: &[P<Type>]) -> Vec<P<IndexInfo>> | checker.go:13728 | Checker
get_union_key | pub(crate) fn get_union_key(types: &[P<Type>], origin: Option<P<Type>>, alias: AliasArg<'_>) -> CacheHashKey | checker.go:17848 | -
get_union_or_evolving_array_type | pub(crate) fn get_union_or_evolving_array_type(&mut self, f: P<FlowState>, types: &[P<Type>], subtype_reduction: UnionReduction) -> P<Type> | flow.go:1314 | Checker
get_union_or_intersection_property | pub(crate) fn get_union_or_intersection_property(&mut self, t: P<Type>, name: &str, skip_object_function_property_augment: bool) -> Option<P<Symbol>> | checker.go:21769 | Checker
get_union_or_intersection_property_lazy_cache | pub(crate) fn get_union_or_intersection_property_lazy_cache(&mut self, t: P<Type>, name: &str, skip_object_function_property_augment: bool) -> Option<P<Symbol>> | rust:checker_11.rs:45 | Checker
get_union_or_intersection_type | pub(crate) fn get_union_or_intersection_type(&mut self, types: &[P<Type>], is_union: bool, union_reduction: UnionReduction) -> P<Type> | checker.go:26080 | Checker
get_union_or_intersection_type_predicate | pub(crate) fn get_union_or_intersection_type_predicate(&mut self, signatures: &[P<Signature>], is_union: bool) -> Option<P<TypePredicate>> | relater.go:2083 | Checker
get_union_signatures | pub(crate) fn get_union_signatures(&mut self, signature_lists: &[Vec<P<Signature>>]) -> Vec<P<Signature>> | checker.go:21453 | Checker
get_union_type | pub fn get_union_type(&mut self, types: &[P<Type>]) -> P<Type> | checker.go:26087 | Checker
get_union_type_ex | pub fn get_union_type_ex(&mut self, types: &[P<Type>], union_reduction: UnionReduction, alias: AliasArg<'_>, origin: Option<P<Type>>) -> P<Type> | checker.go:26098 | Checker
get_union_type_ex_exported | pub fn get_union_type_ex_exported(&mut self, types: &[P<Type>], union_reduction: UnionReduction) -> P<Type> | exports.go:370 | Checker
get_union_type_ex_uncached | pub(crate) fn get_union_type_ex_uncached(&mut self, types: &[P<Type>], union_reduction: UnionReduction, alias: AliasArg<'_>, origin: Option<P<Type>>) -> P<Type> | rust:checker_12.rs:2690 | Checker
get_union_type_exported | pub fn get_union_type_exported(&mut self, types: &[P<Type>]) -> P<Type> | exports.go:80 | Checker
get_union_type_from_sorted_list | pub(crate) fn get_union_type_from_sorted_list(&mut self, types: &[P<Type>], precomputed_object_flags: ObjectFlags, alias: AliasArg<'_>, origin: Option<P<Type>>) -> P<Type> | checker.go:26206 | Checker
get_union_type_front_cached | pub(crate) fn get_union_type_front_cached(&mut self, types: &[P<Type>], union_reduction: UnionReduction, alias: AliasArg<'_>) -> P<Type> | rust:unioncache.rs:300 | Checker
get_union_type_long_cached | fn get_union_type_long_cached(&mut self, types: &[P<Type>], union_reduction: UnionReduction, alias: AliasArg<'_>) -> P<Type> | rust:unioncache.rs:243 | Checker
get_union_type_worker | pub(crate) fn get_union_type_worker(&mut self, types: &[P<Type>], union_reduction: UnionReduction, alias: AliasArg<'_>, origin: Option<P<Type>>) -> P<Type> | checker.go:26123 | Checker
get_union_type_worker_inner | fn get_union_type_worker_inner(&mut self, types: &[P<Type>], union_reduction: UnionReduction, alias: AliasArg<'_>, origin: Option<P<Type>>) -> P<Type> | rust:checker_13.rs:38 | Checker
get_uniq_associated_names_from_tuple_type | fn get_uniq_associated_names_from_tuple_type(t: P<Type>, rest_symbol: P<Symbol>) -> Vec<String> | rust:nodebuilderimpl_2.rs:152 | -
get_unique_literal_type_for_type_parameter | pub(crate) fn get_unique_literal_type_for_type_parameter(&mut self, t: P<Type>) -> P<Type> | checker.go:25415 | Checker
get_unique_type_parameter_name | pub(crate) fn get_unique_type_parameter_name(type_parameters: &[P<Type>], base_name: &str) -> String | checker.go:7889 | -
get_unique_type_parameters | pub(crate) fn get_unique_type_parameters(&mut self, context: P<InferenceContext>, type_parameters: &[P<Type>]) -> Vec<P<Type>> | checker.go:7856 | Checker
get_unknown_signature | pub fn get_unknown_signature(&self) -> P<Signature> | exports.go:76 | Checker
get_unknown_symbol | pub fn get_unknown_symbol(&self) -> P<Symbol> | exports.go:64 | Checker
get_unknown_type | pub fn get_unknown_type(&self) -> P<Type> | exports.go:44 | Checker
get_unmatched_properties | pub(crate) fn get_unmatched_properties(&mut self, source: P<Type>, target: P<Type>, require_optional_properties: bool, match_discriminant_properties: bool) -> Vec<P<Symbol>> | relater.go:971 | Checker
get_unmatched_properties_worker | pub(crate) fn get_unmatched_properties_worker(&mut self, source: P<Type>, target: P<Type>, require_optional_properties: bool, match_discriminant_properties: bool, props_out: Option<&mut Vec<P<Symbol>>>) -> Option<P<Symbol>> | relater.go:977 | Checker
get_unmatched_properties_worker_ex | fn get_unmatched_properties_worker_ex(&mut self, source: P<Type>, target: P<Type>, require_optional_properties: bool, match_discriminant_properties: bool, props_out: Option<&mut Vec<P<Symbol>>>, found: Option<&mut Vec<Option<Option<P<Symbol>>>>>) -> Option<P<Symbol>> | rust:relater_1.rs:1523 | Checker
get_unmatched_property | pub(crate) fn get_unmatched_property(&mut self, source: P<Type>, target: P<Type>, require_optional_properties: bool, match_discriminant_properties: bool) -> Option<P<Symbol>> | relater.go:967 | Checker
get_unmatched_property_recording | pub(crate) fn get_unmatched_property_recording(&mut self, source: P<Type>, target: P<Type>, require_optional_properties: bool, found: &mut Vec<Option<Option<P<Symbol>>>>) -> Option<P<Symbol>> | rust:relater_1.rs:1506 | Checker
get_unresolved_symbol_for_entity_name | pub(crate) fn get_unresolved_symbol_for_entity_name(&mut self, name: P<Node>) -> P<Symbol> | checker.go:23563 | Checker
get_variable_declaration_of_object_literal | pub(crate) fn get_variable_declaration_of_object_literal(&mut self, symbol: P<Symbol>, meaning: SymbolFlags) -> Option<P<Symbol>> | symbolaccessibility.go:226 | Checker
get_variance_stack_index | pub(crate) fn get_variance_stack_index(&self, symbol: P<Symbol>) -> Option<usize> | relater.go:1437 | Checker
get_variances | pub(crate) fn get_variances(&mut self, t: P<Type>) -> Vec<VarianceFlags> | relater.go:1317 | Checker
get_variances_worker | pub(crate) fn get_variances_worker(&mut self, symbol: P<Symbol>, type_parameters: &'static [P<Type>]) -> Vec<VarianceFlags> | relater.go:1334 | Checker
get_verbatim_module_syntax_error_message | pub(crate) fn get_verbatim_module_syntax_error_message(node: P<Node>) -> &'static Message | checker.go:5846 | -
get_void_type | pub fn get_void_type(&self) -> P<Type> | exports.go:20 | Checker
get_widened_literal_like_type_for_contextual_iteration_type_if_needed | pub(crate) fn get_widened_literal_like_type_for_contextual_iteration_type_if_needed(&mut self, t: Option<P<Type>>, contextual_signature_return_type: Option<P<Type>>, kind: IterationTypeKind, is_async_generator: bool) -> Option<P<Type>> | checker.go:20764 | Checker
get_widened_literal_like_type_for_contextual_return_type_if_needed | pub(crate) fn get_widened_literal_like_type_for_contextual_return_type_if_needed(&mut self, t: Option<P<Type>>, contextual_signature_return_type: Option<P<Type>>, is_async: bool) -> Option<P<Type>> | checker.go:20748 | Checker
get_widened_literal_like_type_for_contextual_type | pub(crate) fn get_widened_literal_like_type_for_contextual_type(&mut self, t: P<Type>, contextual_type: Option<P<Type>>) -> P<Type> | checker.go:25985 | Checker
get_widened_literal_type | pub fn get_widened_literal_type(&mut self, t: P<Type>) -> P<Type> | checker.go:25957 | Checker
get_widened_literal_type_exported | pub fn get_widened_literal_type_exported(&mut self, t: P<Type>) -> P<Type> | exports.go:362 | Checker
get_widened_literal_type_for_initializer | pub(crate) fn get_widened_literal_type_for_initializer(&mut self, declaration: P<Node>, t: P<Type>) -> P<Type> | checker.go:17221 | Checker
get_widened_property | pub(crate) fn get_widened_property(&mut self, prop: P<Symbol>, context: Option<P<WideningContext>>) -> P<Symbol> | checker.go:18776 | Checker
get_widened_type | pub fn get_widened_type(&mut self, t: P<Type>) -> P<Type> | checker.go:18699 | Checker
get_widened_type_exported | pub fn get_widened_type_exported(&mut self, t: P<Type>) -> P<Type> | exports.go:390 | Checker
get_widened_type_for_assignment_declaration | pub(crate) fn get_widened_type_for_assignment_declaration(&mut self, symbol: P<Symbol>) -> P<Type> | checker.go:18403 | Checker
get_widened_type_for_variable_like_declaration | pub(crate) fn get_widened_type_for_variable_like_declaration(&mut self, declaration: P<Node>, report_errors: bool) -> P<Type> | checker.go:16970 | Checker
get_widened_type_of_object_literal | pub(crate) fn get_widened_type_of_object_literal(&mut self, t: P<Type>, context: Option<P<WideningContext>>) -> P<Type> | checker.go:18744 | Checker
get_widened_type_with_context | pub(crate) fn get_widened_type_with_context(&mut self, t: P<Type>, context: Option<P<WideningContext>>) -> P<Type> | checker.go:18703 | Checker
get_widened_unique_es_symbol_type | pub(crate) fn get_widened_unique_es_symbol_type(&mut self, t: P<Type>) -> P<Type> | checker.go:25975 | Checker
get_with_alternative_containers | pub(crate) fn get_with_alternative_containers(&mut self, container: P<Symbol>, symbol: P<Symbol>, enclosing_declaration: Option<P<Node>>, meaning: SymbolFlags) -> Vec<P<Symbol>> | symbolaccessibility.go:117 | Checker
get_write_type_of_accessors | pub(crate) fn get_write_type_of_accessors(&mut self, symbol: P<Symbol>) -> P<Type> | checker.go:18910 | Checker
get_write_type_of_instantiated_symbol | pub(crate) fn get_write_type_of_instantiated_symbol(&mut self, symbol: P<Symbol>) -> P<Type> | checker.go:16859 | Checker
get_write_type_of_symbol | pub(crate) fn get_write_type_of_symbol(&mut self, symbol: P<Symbol>) -> Option<P<Type>> | checker.go:16757 | Checker
get_write_type_of_symbol_with_deferred_type | pub(crate) fn get_write_type_of_symbol_with_deferred_type(&mut self, symbol: P<Symbol>) -> P<Type> | checker.go:16737 | Checker
get_yielded_type_of_yield_expression | pub(crate) fn get_yielded_type_of_yield_expression(&mut self, node: P<Node>, expression_type: P<Type>, sent_type: P<Type>, is_async: bool) -> Option<P<Type>> | checker.go:11218 | Checker
given_or_pending | pub fn given_or_pending(alias: Option<P<TypeAlias>>, pending: Option<&'a PendingTypeAlias>) -> AliasArg<'a> | rust:types.rs:1152 | AliasArg
grammar_error_at_pos | pub(crate) fn grammar_error_at_pos(&mut self, node_for_source_file: P<Node>, start: u32, length: u32, message: &'static Message, args: &[&dyn Display]) -> bool | grammarchecks.go:29 | Checker
grammar_error_on_first_token | pub(crate) fn grammar_error_on_first_token(&mut self, node: P<Node>, message: &'static Message, args: &[&dyn Display]) -> bool | grammarchecks.go:19 | Checker
grammar_error_on_node | pub(crate) fn grammar_error_on_node(&mut self, node: P<Node>, message: &'static Message, args: &[&dyn Display]) -> bool | grammarchecks.go:38 | Checker
grammar_error_on_node_skipped_on_no_emit | pub(crate) fn grammar_error_on_node_skipped_on_no_emit(&mut self, node: P<Node>, message: &'static Message, args: &[&dyn Display]) -> bool | grammarchecks.go:47 | Checker
has | pub fn has(&self, key: &K) -> bool | rust:types.rs:107 | GoMap
has | pub fn has(&self, id: u64) -> bool | rust:links.rs:464 | IdLinkStore
has | pub fn has(&self, key: P<K>) -> bool | rust:links.rs:245 | KeyedLinkStore
has | pub fn has(&self, key: P<K>) -> bool | rust:links.rs:93 | LinkStore
has | pub fn has(&self, symbol: P<Symbol>) -> bool | rust:links.rs:776 | SymbolArenaLinkStore
has_array_or_type_type_constraint | pub(crate) fn has_array_or_type_type_constraint(&mut self, type_variable: P<Type>) -> bool | checker.go:23005 | Checker
has_async_modifier | pub(crate) fn has_async_modifier(node: P<Node>) -> bool | utilities.go:59 | -
has_base_type | pub(crate) fn has_base_type(&mut self, t: P<Type>, check_base: Option<P<Type>>) -> bool | checker.go:19892 | Checker
has_base_type_check | fn has_base_type_check(c: &mut Checker, t: P<Type>, check_base: Option<P<Type>>) -> bool | rust:checker_10.rs:365 | -
has_bindable_name | pub(crate) fn has_bindable_name(&mut self, node: P<Node>) -> bool | checker.go:20282 | Checker
has_common_declaration | pub(crate) fn has_common_declaration(symbols: &[P<Symbol>]) -> bool | checker.go:22041 | Checker
has_common_dom_type_name | pub(crate) fn has_common_dom_type_name(t: P<Type>) -> bool | checker.go:11859 | -
has_common_properties | pub(crate) fn has_common_properties(&mut self, source: P<Type>, target: P<Type>, is_comparing_jsx_attributes: bool) -> bool | relater.go:695 | Checker
has_context_sensitive_return_expression | pub(crate) fn has_context_sensitive_return_expression(&mut self, node: P<Node>) -> bool | checker.go:31424 | Checker
has_context_sensitive_yield_expression | pub(crate) fn has_context_sensitive_yield_expression(&mut self, node: P<Node>) -> bool | checker.go:31440 | Checker
has_contextual_type_with_no_generic_types | pub(crate) fn has_contextual_type_with_no_generic_types(&mut self, node: P<Node>, check_mode: CheckMode) -> bool | checker.go:32022 | Checker
has_correct_arity | pub(crate) fn has_correct_arity(&mut self, node: P<Node>, args: &[P<Node>], signature: P<Signature>, signature_help_trailing_comma: bool) -> bool | checker.go:9299 | Checker
has_correct_type_argument_arity | pub(crate) fn has_correct_type_argument_arity(signature: P<Signature>, type_arguments: &[P<Node>]) -> bool | checker.go:9406 | Checker
has_covariant_void_argument | pub(crate) fn has_covariant_void_argument(type_arguments: &[P<Type>], variances: &[VarianceFlags]) -> bool | relater.go:1478 | Checker
has_default_value | pub(crate) fn has_default_value(node: P<Node>) -> bool | checker.go:13826 | Checker
has_dot_dot_dot_token | pub(crate) fn has_dot_dot_dot_token(node: P<Node>) -> bool | utilities.go:272 | -
has_effective_rest_parameter | pub fn has_effective_rest_parameter(&mut self, signature: P<Signature>) -> bool | relater.go:1782 | Checker
has_effective_rest_parameter_exported | pub fn has_effective_rest_parameter_exported(&mut self, signature: P<Signature>) -> bool | exports.go:239 | Checker
has_empty_object_intersection | pub(crate) fn has_empty_object_intersection(&mut self, t: P<Type>) -> bool | checker.go:13319 | Checker
has_excess_properties | pub(crate) fn has_excess_properties(&self, c: &mut Checker, source: P<Type>, target: P<Type>, report_errors: bool) -> bool | relater.go:2747 | Relater
has_export_assignment_symbol | pub(crate) fn has_export_assignment_symbol(module_symbol: P<Symbol>) -> bool | utilities.go:256 | -
has_exported_members_of_kind | pub(crate) fn has_exported_members_of_kind(&mut self, module_symbol: P<Symbol>, kind: SymbolFlags) -> bool | checker.go:5903 | Checker
has_external_module_symbol | pub(crate) fn has_external_module_symbol(declaration: P<Node>) -> bool | symbolaccessibility.go:249 | -
has_inference_candidates | pub(crate) fn has_inference_candidates(info: P<InferenceInfo>) -> bool | inference.go:1651 | -
has_inference_candidates_or_default | pub(crate) fn has_inference_candidates_or_default(info: P<InferenceInfo>) -> bool | inference.go:1655 | -
has_intra_expression_inference_sites | pub fn has_intra_expression_inference_sites(&self) -> bool | rust:checker.rs:463 | InferenceContext
has_late_bindable_index_signature | pub(crate) fn has_late_bindable_index_signature(&mut self, node: P<Node>) -> bool | checker.go:20312 | Checker
has_late_bindable_name | pub(crate) fn has_late_bindable_name(&mut self, node: P<Node>) -> bool | checker.go:20289 | Checker
has_matching_argument | pub(crate) fn has_matching_argument(&mut self, expression: P<Node>, reference: P<Node>) -> bool | flow.go:1886 | Checker
has_matching_recursion_identity | pub(crate) fn has_matching_recursion_identity(c: &mut Checker, t: P<Type>, identity: RecursionId) -> bool | relater.go:797 | -
has_non_circular_base_constraint | pub(crate) fn has_non_circular_base_constraint(&mut self, t: P<Type>) -> bool | checker.go:17390 | Checker
has_non_global_augmentation_external_module_symbol | pub(crate) fn has_non_global_augmentation_external_module_symbol(declaration: P<Node>) -> bool | symbolaccessibility.go:105 | -
has_numeric_property_names | pub(crate) fn has_numeric_property_names(&mut self, t: P<Type>) -> bool | checker.go:8388 | Checker
has_only_expression_initializer | pub(crate) fn has_only_expression_initializer(node: P<Node>) -> bool | utilities.go:264 | -
has_overlapping_inferences | pub(crate) fn has_overlapping_inferences(a: &[P<InferenceInfo>], b: &[P<InferenceInfo>]) -> bool | inference.go:1670 | -
has_override_modifier | pub(crate) fn has_override_modifier(node: P<Node>) -> bool | utilities.go:55 | -
has_parent_with_assignments_marked | pub(crate) fn has_parent_with_assignments_marked(&mut self, node: P<Node>) -> bool | flow.go:2688 | Checker
has_parent_with_type_annotation | pub(crate) fn has_parent_with_type_annotation(&mut self, symbol: P<Symbol>) -> bool | checker.go:18487 | Checker
has_parse_diagnostics | pub(crate) fn has_parse_diagnostics(source_file: P<SourceFile>) -> bool | checker.go:14301 | Checker
has_primitive_constraint | pub(crate) fn has_primitive_constraint(&mut self, t: P<Type>) -> bool | inference.go:1482 | Checker
has_properties_of_structured_type | pub(crate) fn has_properties_of_structured_type(&mut self, t: P<Type>) -> bool | rust:checker_09.rs:3225 | Checker
has_properties_of_structured_type_exported | pub fn has_properties_of_structured_type_exported(&mut self, t: P<Type>) -> bool | rust:exports.rs:519 | Checker
has_property_of_type | pub(crate) fn has_property_of_type(&mut self, t: P<Type>, name: &str) -> bool | rust:checker_09.rs:2291 | Checker
has_readonly_modifier | pub(crate) fn has_readonly_modifier(node: P<Node>) -> bool | utilities.go:67 | -
has_rest_parameter | pub(crate) fn has_rest_parameter(signature: P<Node>) -> bool | checker.go:28257 | -
has_rest_parameter | pub fn has_rest_parameter(&self) -> bool | rust:types.rs:3089 | Signature
has_shadowed_namespace | pub(crate) fn has_shadowed_namespace(&mut self, symbol: P<Symbol>) -> bool | checker.go:5912 | Checker
has_signature_with_arity_greater_than | pub(crate) fn has_signature_with_arity_greater_than(&mut self, symbol: P<Symbol>, arity: usize) -> bool | checker.go:29084 | Checker
has_signatures | pub(crate) fn has_signatures(&mut self, t: P<Type>) -> bool | checker.go:15947 | Checker
has_type | pub(crate) fn has_type(node: P<Node>) -> bool | utilities.go:1308 | -
has_type_annotation | pub(crate) fn has_type_annotation(declaration: Option<P<Node>>) -> bool | nodebuilderimpl.go:2234 | -
has_type_facts | pub fn has_type_facts(&mut self, t: P<Type>, mask: TypeFacts) -> bool | checker.go:31467 | Checker
has_type_json_import_attribute | pub(crate) fn has_type_json_import_attribute(node: P<Node>) -> bool | checker.go:5530 | -
has_type_parameter_by_name | pub(crate) fn has_type_parameter_by_name(type_parameters: &[P<Type>], name: &str) -> bool | checker.go:7883 | -
has_type_parameter_default | pub(crate) fn has_type_parameter_default(tp: P<Type>) -> bool | inference.go:1659 | -
has_type_parameter_default | pub(crate) fn has_type_parameter_default(t: P<Type>) -> bool | checker.go:22344 | Checker
has_type_predicate_or_never_return_type | pub(crate) fn has_type_predicate_or_never_return_type(&mut self, sig: P<Signature>) -> bool | flow.go:2211 | Checker
has_types | pub(crate) fn has_types(&self) -> bool | checker.go:6574 | IterationTypes
has_visible_declarations | pub(crate) fn has_visible_declarations(&self, c: &mut Checker, symbol: P<Symbol>, should_compute_alias_to_make_visible: bool) -> Option<P<SymbolAccessibilityResult>> | emitresolver.go:384 | EmitResolver
hash | fn hash(key: PKey) -> u64 | rust:links.rs:219 | KeyedLinkStore
hash | fn hash(key: PKey) -> u64 | rust:links.rs:51 | LinkStore
hash | fn hash(type_arguments: &[P<Type>]) -> u64 | rust:types.rs:2257 | ReferenceInstantiations
hash | fn hash(value: &str) -> u64 | rust:packedmap.rs:192 | StringLiteralTypes
hash | fn hash(key: PKey) -> u64 | rust:links.rs:320 | SymbolReferenceLinkStore
hash | pub(crate) fn hash(&self) -> CacheHashKey | checker.go:17713 | keyBuilder
hash_128 | pub fn hash_128(b: &[u8]) -> CacheHashKey | rust:checker.rs:3022 | CacheHashKey
hash_spilled | fn hash_spilled(&self, overflow: &[u8]) -> CacheHashKey | rust:checker_09.rs:386 | keyBuilder
hash_string_128 | pub const fn hash_string_128(s: &str) -> CacheHashKey | rust:checker.rs:3026 | CacheHashKey
hit | pub fn hit(_kind: &'static str, _label: &'static str) | rust:sitecount.rs:80 | -
hit_n | pub fn hit_n(_kind: &'static str, _label: &'static str, _n: u64) | rust:sitecount.rs:84 | -
hover_heritage_clauses | pub(crate) fn hover_heritage_clauses(&self, _c: &mut Checker, declarations: &[P<Node>]) -> Vec<P<Node>> | nodebuilder_hover.go:275 | NodeBuilderImpl
id | pub fn id(&self) -> SignatureId | rust:types.rs:3009 | Signature
id | pub fn id(&self) -> TypeId | rust:types.rs:1452 | Type
import_clause_from_imported | pub(crate) fn import_clause_from_imported(node: P<Node>) -> Option<P<Node>> | checker.go:7443 | -
include_mixin_type | pub(crate) fn include_mixin_type(&mut self, t: P<Type>, types: &[P<Type>], mixin_flags: &[bool], index: usize) -> P<Type> | checker.go:21728 | Checker
include_undefined_in_index_signature | pub(crate) fn include_undefined_in_index_signature(&mut self, t: P<Type>) -> P<Type> | flow.go:2339 | Checker
index | fn index(&self, key: P<K>) -> Option<u32> | rust:links.rs:75 | LinkStore
index_by_pkey | fn index_by_pkey(&self, key: PKey) -> Option<u32> | rust:links.rs:80 | LinkStore
index_info_related_to | pub(crate) fn index_info_related_to(&self, c: &mut Checker, source_info: P<IndexInfo>, target_info: P<IndexInfo>, report_errors: bool, intersection_state: IntersectionState) -> Ternary | relater.go:4710 | Relater
index_info_to_index_signature_declaration | pub fn index_info_to_index_signature_declaration(&self, c: &mut Checker, info: P<IndexInfo>, enclosing_declaration: Option<P<Node>>, flags: Flags, internal_flags: InternalFlags, tracker: Option<&'static dyn SymbolTracker>) -> Option<P<Node>> | nodebuilder.go:111 | NodeBuilder
index_info_to_index_signature_declaration_helper | pub(crate) fn index_info_to_index_signature_declaration_helper(&self, c: &mut Checker, index_info: P<IndexInfo>, type_node: Option<P<Node>>) -> P<Node> | nodebuilderimpl.go:2210 | NodeBuilderImpl
index_info_to_object_computed_names_or_signature_declaration | pub(crate) fn index_info_to_object_computed_names_or_signature_declaration(&self, c: &mut Checker, index_info: P<IndexInfo>, type_node: Option<P<Node>>) -> Vec<P<Node>> | nodebuilderimpl.go:2159 | NodeBuilderImpl
index_infos | fn index_infos(&self) -> &'static [P<IndexInfo>] | rust:types.rs:2093 | CountOrIndexInfos
index_infos | pub fn index_infos(&self) -> &'static [P<IndexInfo>] | rust:types.rs:2162 | StructuredType
index_infos_of_structured_type | pub(crate) fn index_infos_of_structured_type(&mut self, t: P<Type>) -> &'static [P<IndexInfo>] | rust:checker_09.rs:2536 | Checker
index_infos_of_unresolved_structured_type | fn index_infos_of_unresolved_structured_type(&mut self, t: P<Type>) -> &'static [P<IndexInfo>] | rust:checker_09.rs:2544 | Checker
index_signatures_identical_to | pub(crate) fn index_signatures_identical_to(&self, c: &mut Checker, source: P<Type>, target: P<Type>) -> Ternary | relater.go:4722 | Relater
index_signatures_related_to | pub(crate) fn index_signatures_related_to(&self, c: &mut Checker, source: P<Type>, target: P<Type>, source_is_primitive: bool, report_errors: bool, intersection_state: IntersectionState) -> Ternary | relater.go:4610 | Relater
index_type | pub fn index_type(&self) -> Option<P<Type>> | rust:types.rs:2817 | IndexedAccessType
index_type_less_than | pub(crate) fn index_type_less_than(c: &mut Checker, index_type: P<Type>, limit: usize) -> bool | checker.go:27851 | -
indexed_access_memo_mode | pub(crate) fn indexed_access_memo_mode() -> UnionCacheMode | rust:unioncache.rs:61 | -
infer_from_annotated_parameters_and_return | pub(crate) fn infer_from_annotated_parameters_and_return(&mut self, sig: P<Signature>, context: P<Signature>, inference_context: Option<P<InferenceContext>>) | checker.go:10436 | Checker
infer_from_contravariant_types | pub(crate) fn infer_from_contravariant_types(&mut self, n: P<InferenceState>, source: P<Type>, target: P<Type>) | inference.go:308 | Checker
infer_from_contravariant_types_if_strict_function_types | pub(crate) fn infer_from_contravariant_types_if_strict_function_types(&mut self, n: P<InferenceState>, source: P<Type>, target: P<Type>) | inference.go:314 | Checker
infer_from_contravariant_types_with_priority | pub(crate) fn infer_from_contravariant_types_with_priority(&mut self, n: P<InferenceState>, source: P<Type>, target: P<Type>, new_priority: InferencePriority) | inference.go:301 | Checker
infer_from_generic_mapped_types | pub(crate) fn infer_from_generic_mapped_types(&mut self, n: P<InferenceState>, source: P<Type>, target: P<Type>) | inference.go:687 | Checker
infer_from_index_types | pub(crate) fn infer_from_index_types(&mut self, n: P<InferenceState>, source: P<Type>, target: P<Type>) | inference.go:911 | Checker
infer_from_intra_expression_sites | pub(crate) fn infer_from_intra_expression_sites(&mut self, n: P<InferenceContext>) | inference.go:1302 | Checker
infer_from_literal_parts_to_template_literal | pub(crate) fn infer_from_literal_parts_to_template_literal(&mut self, source_texts: &[&str], source_types: &[P<Type>], target: &'static TemplateLiteralType) -> Vec<P<Type>> | relater.go:2418 | Checker
infer_from_matching_types | pub(crate) fn infer_from_matching_types<'a, 'b>(&mut self, n: P<InferenceState>, sources: &'a [P<Type>], targets: &'b [P<Type>], matches: impl FnMut(&mut Checker, P<Type>, P<Type>) -> bool, sort: bool) -> (std::borrow::Cow<'a, [P<Type>]>, std::borrow::Cow<'b, [P<Type>]>) | inference.go:370 | Checker
infer_from_object_types | pub(crate) fn infer_from_object_types(&mut self, n: P<InferenceState>, source: P<Type>, target: P<Type>) | inference.go:699 | Checker
infer_from_properties | pub(crate) fn infer_from_properties(&mut self, n: P<InferenceState>, source: P<Type>, target: P<Type>) | inference.go:828 | Checker
infer_from_signature | pub(crate) fn infer_from_signature(&mut self, n: P<InferenceState>, source: P<Signature>, target: P<Signature>) | inference.go:853 | Checker
infer_from_signatures | pub(crate) fn infer_from_signatures(&mut self, n: P<InferenceState>, source: P<Type>, target: P<Type>, kind: SignatureKind) | inference.go:838 | Checker
infer_from_type_arguments | pub(crate) fn infer_from_type_arguments(&mut self, n: P<InferenceState>, source_types: &[P<Type>], target_types: &[P<Type>], variances: &[VarianceFlags]) | inference.go:284 | Checker
infer_from_types | pub(crate) fn infer_from_types(&mut self, n: P<InferenceState>, source: P<Type>, target: P<Type>) | inference.go:65 | Checker
infer_from_types_memo | pub(crate) fn infer_from_types_memo(&mut self, n: P<InferenceState>, source: P<Type>, target: P<Type>) | rust:infermemo.rs:193 | Checker
infer_jsx_type_arguments | pub(crate) fn infer_jsx_type_arguments(&mut self, node: P<Node>, signature: P<Signature>, check_mode: CheckMode, context: P<InferenceContext>) -> Vec<P<Type>> | jsx.go:198 | Checker
infer_memo_effects | fn infer_memo_effects(&self) -> Effects | rust:infermemo.rs:181 | Checker
infer_memo_finish | pub fn infer_memo_finish() | rust:infermemo.rs:356 | Checker
infer_memo_key | fn infer_memo_key(&self, key: &mut Vec<u32>, n: P<InferenceState>, source: P<Type>, target: P<Type>) -> bool | rust:infermemo.rs:283 | Checker
infer_memo_mode | fn infer_memo_mode() -> InferMemoMode | rust:infermemo.rs:75 | -
infer_memo_shadow | fn infer_memo_shadow(&mut self, n: P<InferenceState>, source: P<Type>, target: P<Type>, key: &[u32]) | rust:infermemo.rs:320 | Checker
infer_reverse_mapped_type | pub(crate) fn infer_reverse_mapped_type(&mut self, source: P<Type>, target: P<Type>, constraint: P<Type>) -> Option<P<Type>> | inference.go:1066 | Checker
infer_reverse_mapped_type_worker | pub(crate) fn infer_reverse_mapped_type_worker(&mut self, source: P<Type>, target: P<Type>, constraint: P<Type>) -> P<Type> | inference.go:1091 | Checker
infer_signature_instantiation_for_overload_failure | pub(crate) fn infer_signature_instantiation_for_overload_failure(&mut self, node: P<Node>, type_parameters: &[P<Type>], candidate: P<Signature>, args: &[P<Node>], check_mode: CheckMode) -> P<Signature> | checker.go:9767 | Checker
infer_to_conditional_type | pub(crate) fn infer_to_conditional_type(&mut self, n: P<InferenceState>, source: P<Type>, target: P<Type>) | inference.go:554 | Checker
infer_to_mapped_type | pub(crate) fn infer_to_mapped_type(&mut self, n: P<InferenceState>, source: P<Type>, target: P<Type>, constraint_type: P<Type>) -> bool | inference.go:948 | Checker
infer_to_multiple_types | pub(crate) fn infer_to_multiple_types(&mut self, n: P<InferenceState>, source: P<Type>, targets: &[P<Type>], target_flags: TypeFlags) | inference.go:448 | Checker
infer_to_multiple_types_with_priority | pub(crate) fn infer_to_multiple_types_with_priority(&mut self, n: P<InferenceState>, source: P<Type>, targets: &[P<Type>], target_flags: TypeFlags, new_priority: InferencePriority) | inference.go:547 | Checker
infer_to_template_literal_type | pub(crate) fn infer_to_template_literal_type(&mut self, n: P<InferenceState>, source: P<Type>, target: &'static TemplateLiteralType) | inference.go:566 | Checker
infer_to_template_literal_type_choose | fn infer_to_template_literal_type_choose(c: &mut Checker, left: P<Type>, right: P<Type>, all_type_flags: TypeFlags, source: P<Type>, str: &str) -> P<Type> | rust:inference.rs:667 | -
infer_type_arguments | pub(crate) fn infer_type_arguments(&mut self, node: P<Node>, signature: P<Signature>, args: &[P<Node>], check_mode: CheckMode, context: P<InferenceContext>) -> Vec<P<Type>> | checker.go:9582 | Checker
infer_type_arguments_worker | fn infer_type_arguments_worker(&mut self, node: P<Node>, signature: P<Signature>, args: &[P<Node>], check_mode: CheckMode, context: P<InferenceContext>) -> Vec<P<Type>> | rust:checker_05.rs:1038 | Checker
infer_type_for_homomorphic_mapped_type | pub(crate) fn infer_type_for_homomorphic_mapped_type(&mut self, source: P<Type>, target: P<Type>, constraint: P<Type>) -> Option<P<Type>> | inference.go:1004 | Checker
infer_types | pub(crate) fn infer_types(&mut self, inferences: &[P<InferenceInfo>], original_source: P<Type>, original_target: P<Type>, priority: InferencePriority, contravariant: bool) | inference.go:53 | Checker
infer_types_from_template_literal_type | pub(crate) fn infer_types_from_template_literal_type(&mut self, source: P<Type>, target: &'static TemplateLiteralType, compare_types: TypeComparer) -> Vec<P<Type>> | relater.go:2378 | Checker
infer_with_priority | pub(crate) fn infer_with_priority(&mut self, n: P<InferenceState>, source: P<Type>, target: P<Type>, new_priority: InferencePriority) | inference.go:294 | Checker
inferred_type_parameters | pub fn inferred_type_parameters(&self) -> &'static [P<Type>] | rust:checker.rs:455 | InferenceContext
info_outcomes | fn info_outcomes(n: P<InferenceState>) -> Box<[InfoOutcome]> | rust:infermemo.rs:167 | -
initial | fn initial(&self) -> P<Type> | rust:flow.rs:27 | FlowState
initialize_checker | pub(crate) fn initialize_checker(&mut self) | checker.go:1306 | Checker
initialize_closures | pub(crate) fn initialize_closures(&self) | checker.go:1256 | Checker
initialize_iteration_resolvers | pub(crate) fn initialize_iteration_resolvers(&mut self) | checker.go:1269 | Checker
insert | pub fn insert(&mut self, key: K, value: V) -> Option<V> | rust:basedmap.rs:49 | Based
insert | pub fn insert(&mut self, key: K, value: V) -> Option<V> | rust:basedmap.rs:86 | Based
insert | pub fn insert(&mut self, source: P<Symbol>, target: P<Symbol>) | rust:merged_symbols.rs:39 | MergedSymbols
insert | pub fn insert(&mut self, key: K, value: V) -> Option<V> | rust:packedmap.rs:84 | PackedMap
insert_new | pub fn insert_new(&mut self, t: P<Type>) | rust:packedmap.rs:221 | StringLiteralTypes
insert_type | pub(crate) fn insert_type(c: &mut Checker, types: &[P<Type>], t: P<Type>) -> (Vec<P<Type>>, bool) | checker.go:27091 | -
instantiate_alias_or_interface_with_defaults | pub(crate) fn instantiate_alias_or_interface_with_defaults(&mut self, managed_sym: P<Symbol>, type_arguments: &[P<Type>], in_java_script: bool) -> Option<P<Type>> | jsx.go:1030 | Checker
instantiate_anonymous_type | pub(crate) fn instantiate_anonymous_type(&mut self, t: P<Type>, m: P<TypeMapper>, alias: Option<P<TypeAlias>>) -> P<Type> | checker.go:22883 | Checker
instantiate_contextual_type | pub(crate) fn instantiate_contextual_type(&mut self, contextual_type: Option<P<Type>>, node: P<Node>, context_flags: ContextFlags) -> Option<P<Type>> | checker.go:31306 | Checker
instantiate_index_info | pub(crate) fn instantiate_index_info(&mut self, info: P<IndexInfo>, m: Option<P<TypeMapper>>) -> P<IndexInfo> | checker.go:20983 | Checker
instantiate_index_infos | pub(crate) fn instantiate_index_infos(&mut self, index_infos: &[P<IndexInfo>], m: P<TypeMapper>) -> Vec<P<IndexInfo>> | checker.go:23204 | Checker
instantiate_instantiable_types | pub(crate) fn instantiate_instantiable_types(&mut self, t: P<Type>, mapper: P<TypeMapper>) -> P<Type> | checker.go:31344 | Checker
instantiate_list | pub(crate) fn instantiate_list<T: Copy + Eq + std::hash::Hash>(&mut self, values: &[T], m: Option<P<TypeMapper>>, instantiator: impl FnMut(&mut Checker, T, Option<P<TypeMapper>>) -> T) -> Vec<T> | checker.go:23208 | Checker
instantiate_mapped_array_type | pub(crate) fn instantiate_mapped_array_type(&mut self, array_type: P<Type>, mapped_type: P<Type>, m: P<TypeMapper>) -> P<Type> | checker.go:23010 | Checker
instantiate_mapped_tuple_type | pub(crate) fn instantiate_mapped_tuple_type(&mut self, tuple_type: P<Type>, mapped_type: P<Type>, type_variable: P<Type>, m: P<TypeMapper>) -> P<Type> | checker.go:23018 | Checker
instantiate_mapped_type | pub(crate) fn instantiate_mapped_type(&mut self, t: P<Type>, m: P<TypeMapper>, alias: Option<P<TypeAlias>>) -> P<Type> | checker.go:22960 | Checker
instantiate_mapped_type_constituent | fn instantiate_mapped_type_constituent(&mut self, t: P<Type>, type_variable: P<Type>, m: P<TypeMapper>, s: P<Type>) -> P<Type> | rust:checker_11.rs:1727 | Checker
instantiate_mapped_type_template | pub(crate) fn instantiate_mapped_type_template(&mut self, t: P<Type>, key: P<Type>, is_optional: bool, m: P<TypeMapper>) -> P<Type> | checker.go:23071 | Checker
instantiate_reverse_mapped_type | pub(crate) fn instantiate_reverse_mapped_type(&mut self, t: P<Type>, m: P<TypeMapper>) -> P<Type> | checker.go:23167 | Checker
instantiate_signature | pub(crate) fn instantiate_signature(&mut self, sig: P<Signature>, m: Option<P<TypeMapper>>) -> P<Signature> | checker.go:20956 | Checker
instantiate_signature_ex | pub(crate) fn instantiate_signature_ex(&mut self, sig: P<Signature>, m: P<TypeMapper>, erase_type_parameters: bool) -> P<Signature> | checker.go:20960 | Checker
instantiate_signature_in_context_of | pub(crate) fn instantiate_signature_in_context_of(&mut self, signature: P<Signature>, contextual_signature: P<Signature>, inference_context: Option<P<InferenceContext>>, compare_types: Option<TypeComparer>) -> P<Signature> | checker.go:19807 | Checker
instantiate_signatures | pub(crate) fn instantiate_signatures(&mut self, signatures: &[P<Signature>], m: P<TypeMapper>) -> Vec<P<Signature>> | checker.go:23200 | Checker
instantiate_symbol | pub(crate) fn instantiate_symbol(&mut self, symbol: P<Symbol>, m: Option<P<TypeMapper>>) -> P<Symbol> | checker.go:21094 | Checker
instantiate_symbol_table | pub(crate) fn instantiate_symbol_table(&mut self, symbols: Option<P<SymbolTable>>, m: P<TypeMapper>) -> Option<P<SymbolTable>> | checker.go:21081 | Checker
instantiate_symbols | pub(crate) fn instantiate_symbols(&mut self, symbols: &[P<Symbol>], m: P<TypeMapper>) -> Vec<P<Symbol>> | checker.go:23196 | Checker
instantiate_type | pub(crate) fn instantiate_type(&mut self, t: P<Type>, m: Option<P<TypeMapper>>) -> P<Type> | checker.go:22496 | Checker
instantiate_type_alias | pub(crate) fn instantiate_type_alias(&mut self, alias: Option<P<TypeAlias>>, m: Option<P<TypeMapper>>) -> Option<P<TypeAlias>> | checker.go:23185 | Checker
instantiate_type_alias_pending | pub(crate) fn instantiate_type_alias_pending(&mut self, alias: Option<P<TypeAlias>>, m: Option<P<TypeMapper>>) -> Option<PendingTypeAlias> | rust:checker_11.rs:1976 | Checker
instantiate_type_or_nil | fn instantiate_type_or_nil(c: &mut Checker, t: Option<P<Type>>, m: Option<P<TypeMapper>>) -> Option<P<Type>> | rust:relater_2.rs:17 | -
instantiate_type_predicate | pub(crate) fn instantiate_type_predicate(&mut self, predicate: P<TypePredicate>, mapper: P<TypeMapper>) -> P<TypePredicate> | relater.go:2133 | Checker
instantiate_type_with_alias | pub(crate) fn instantiate_type_with_alias(&mut self, t: P<Type>, m: Option<P<TypeMapper>>, alias: Option<P<TypeAlias>>) -> P<Type> | checker.go:22500 | Checker
instantiate_type_with_alias_slow | fn instantiate_type_with_alias_slow(&mut self, t: P<Type>, m: P<TypeMapper>, alias: Option<P<TypeAlias>>) -> P<Type> | rust:checker_11.rs:1036 | Checker
instantiate_type_with_alias_worker | fn instantiate_type_with_alias_worker(&mut self, t: P<Type>, m: P<TypeMapper>, alias: Option<P<TypeAlias>>) -> P<Type> | rust:checker_11.rs:1046 | Checker
instantiate_type_with_single_generic_call_signature | pub(crate) fn instantiate_type_with_single_generic_call_signature(&mut self, node: P<Node>, t: P<Type>, check_mode: CheckMode) -> P<Type> | checker.go:7771 | Checker
instantiate_type_worker | pub(crate) fn instantiate_type_worker(&mut self, t: P<Type>, m: P<TypeMapper>, alias: Option<P<TypeAlias>>) -> P<Type> | checker.go:22645 | Checker
instantiate_types | pub(crate) fn instantiate_types(&mut self, types: &[P<Type>], m: Option<P<TypeMapper>>) -> Vec<P<Type>> | checker.go:23192 | Checker
instantiate_types_changed | pub(crate) fn instantiate_types_changed(&mut self, types: &[P<Type>], m: P<TypeMapper>) -> Option<Vec<P<Type>>> | rust:checker_11.rs:1990 | Checker
intersect_types | pub(crate) fn intersect_types(&mut self, type1: Option<P<Type>>, type2: Option<P<Type>>) -> Option<P<Type>> | checker.go:26494 | Checker
intersect_unions_of_primitive_types | pub(crate) fn intersect_unions_of_primitive_types(&mut self, types: &[P<Type>]) -> (Vec<P<Type>>, bool) | checker.go:26813 | Checker
intersection_has_matching_recursion_identity | fn intersection_has_matching_recursion_identity(c: &mut Checker, target: P<Type>, identity: RecursionId) -> bool | rust:relater_1.rs:1257 | -
intersection_rare | fn intersection_rare(&self) -> Option<&'static IntersectionRare> | rust:types.rs:2716 | IntersectionType
intersection_rare_for_write | fn intersection_rare_for_write(&self) -> &'static IntersectionRare | rust:types.rs:2722 | IntersectionType
intersection_recursion_keys | fn intersection_recursion_keys(c: &mut Checker, target: P<Type>) -> &'static [u64] | rust:relater_1.rs:1264 | -
intersects | pub fn intersects(self, other: Self) -> bool | rust:checker.rs:663 | InferencePriority
intra_expression_inference_sites | pub fn intra_expression_inference_sites(&self) -> Vec<IntraExpressionInferenceSite> | rust:checker.rs:466 | InferenceContext
intrinsic_name | pub fn intrinsic_name(&self) -> &'static str | rust:types.rs:1957 | IntrinsicType
introduces_arguments_exotic_object | pub(crate) fn introduces_arguments_exotic_object(node: P<Node>) -> bool | utilities.go:1681 | -
invocation_error | pub(crate) fn invocation_error(&mut self, error_target: P<Node>, apparent_type: P<Type>, kind: SignatureKind, related_information: Option<P<Diagnostic>>) | checker.go:10188 | Checker
invocation_error_details | pub(crate) fn invocation_error_details(&mut self, error_target: P<Node>, apparent_type: P<Type>, kind: SignatureKind) -> P<Diagnostic> | checker.go:10132 | Checker
invocation_error_recovery | pub(crate) fn invocation_error_recovery(&mut self, apparent_type: P<Type>, kind: SignatureKind, diagnostic: P<Diagnostic>) | checker.go:10197 | Checker
invoke_once | pub(crate) fn invoke_once(&mut self, n: P<InferenceState>, source: P<Type>, target: P<Type>, action: impl FnMut(&mut Checker, P<InferenceState>, P<Type>, P<Type>)) | inference.go:335 | Checker
is_accessible | pub(crate) fn is_accessible(&mut self, ctx: &accessibleSymbolChainContext, symbol_from_symbol_table: P<Symbol>, resolved_alias_symbol: Option<P<Symbol>>, ignore_qualification: bool) -> bool | symbolaccessibility.go:647 | Checker
is_actively_expanding | pub(crate) fn is_actively_expanding(&self, _c: &mut Checker) -> bool | nodebuilderimpl.go:231 | NodeBuilderImpl
is_additive_operator | pub(crate) fn is_additive_operator(kind: Kind) -> bool | utilities.go:812 | -
is_additive_operator_or_higher | pub(crate) fn is_additive_operator_or_higher(kind: Kind) -> bool | utilities.go:816 | -
is_alias_resolved_to_value | pub(crate) fn is_alias_resolved_to_value(&self, c: &mut Checker, symbol: Option<P<Symbol>>, exclude_type_only_values: bool) -> bool | emitresolver.go:764 | EmitResolver
is_any_symbol_accessible | pub fn is_any_symbol_accessible(&mut self, symbols: &[P<Symbol>], enclosing_declaration: Option<P<Node>>, initial_symbol: P<Symbol>, meaning: SymbolFlags, should_compute_aliases_to_make_visible: bool, allow_modules: bool) -> Option<P<SymbolAccessibilityResult>> | symbolaccessibility.go:26 | Checker
is_applicable_index_type | pub(crate) fn is_applicable_index_type(&mut self, source: P<Type>, target: P<Type>) -> bool | checker.go:19398 | Checker
is_arguments_symbol | pub fn is_arguments_symbol(&self, symbol: P<Symbol>) -> bool | services.go:240 | Checker
is_arity_smaller | pub(crate) fn is_arity_smaller(&mut self, signature: P<Signature>, target: P<Node>) -> bool | checker.go:10530 | Checker
is_array_like_type | pub fn is_array_like_type(&mut self, t: P<Type>) -> bool | checker.go:23981 | Checker
is_array_like_type_exported | pub fn is_array_like_type_exported(&mut self, t: P<Type>) -> bool | exports.go:135 | Checker
is_array_or_tuple_like_type | pub(crate) fn is_array_or_tuple_like_type(&mut self, t: P<Type>) -> bool | checker.go:24017 | Checker
is_array_or_tuple_or_intersection | pub(crate) fn is_array_or_tuple_or_intersection(&mut self, t: P<Type>) -> bool | checker.go:24021 | Checker
is_array_or_tuple_symbol | pub(crate) fn is_array_or_tuple_symbol(&mut self, symbol: Option<P<Symbol>>) -> bool | checker.go:21435 | Checker
is_array_or_tuple_type | pub fn is_array_or_tuple_type(&mut self, t: P<Type>) -> bool | checker.go:23966 | Checker
is_array_type | pub fn is_array_type(&self, t: P<Type>) -> bool | checker.go:23942 | Checker
is_array_type_exported | pub fn is_array_type_exported(&self, t: P<Type>) -> bool | exports.go:227 | Checker
is_assignment_to_readonly_entity | pub(crate) fn is_assignment_to_readonly_entity(&mut self, expr: P<Node>, symbol: P<Symbol>, assignment_kind: AssignmentKind) -> bool | checker.go:27749 | Checker
is_auto_typed_property | pub(crate) fn is_auto_typed_property(&self, symbol: P<Symbol>) -> bool | checker.go:27808 | Checker
is_awaited_type_instantiation | pub(crate) fn is_awaited_type_instantiation(&mut self, t: P<Type>) -> bool | checker.go:31873 | Checker
is_awaited_type_needed | pub(crate) fn is_awaited_type_needed(&mut self, t: P<Type>) -> bool | checker.go:31881 | Checker
is_big_int_literal | pub fn is_big_int_literal(&self) -> bool | rust:types.rs:1732 | Type
is_block_scoped_name_declared_before_use | pub(crate) fn is_block_scoped_name_declared_before_use(&mut self, declaration: P<Node>, usage: P<Node>) -> bool | checker.go:1963 | Checker
is_boolean_like | pub fn is_boolean_like(&self) -> bool | rust:types.rs:1742 | Type
is_call_chain | pub(crate) fn is_call_chain(node: P<Node>) -> bool | utilities.go:1128 | -
is_canceled | pub(crate) fn is_canceled(&self) -> bool | utilities.go:1712 | Checker
is_circular_mapped_property | pub(crate) fn is_circular_mapped_property(&mut self, symbol: P<Symbol>) -> bool | checker.go:31152 | Checker
is_class | pub fn is_class(&self) -> bool | rust:types.rs:1752 | Type
is_class_derived_from_declaring_classes | pub(crate) fn is_class_derived_from_declaring_classes(&mut self, check_class: P<Type>, prop: P<Symbol>, writing: bool) -> bool | checker.go:12181 | Checker
is_class_instance_property | pub(crate) fn is_class_instance_property(node: P<Node>) -> bool | utilities.go:1060 | -
is_class_instance_side | pub(crate) fn is_class_instance_side(c: &mut Checker, t: P<Type>) -> bool | nodebuilderimpl.go:337 | -
is_coercible_under_double_equals | pub(crate) fn is_coercible_under_double_equals(source: P<Type>, target: P<Type>) -> bool | flow.go:1928 | -
is_common_js_module_exports | pub(crate) fn is_common_js_module_exports(node: P<Node>) -> bool | emitresolver.go:249 | -
is_common_js_require | pub(crate) fn is_common_js_require(&mut self, node: P<Node>) -> bool | checker.go:15997 | Checker
is_compound_like_assignment | pub(crate) fn is_compound_like_assignment(assignment: P<Node>) -> bool | utilities.go:122 | -
is_conflicting_private_property | pub(crate) fn is_conflicting_private_property(prop: P<Symbol>) -> bool | checker.go:22284 | -
is_const_context | pub(crate) fn is_const_context(&mut self, node: P<Node>) -> bool | checker.go:13833 | Checker
is_const_context_ex | fn is_const_context_ex(&mut self, node: P<Node>) -> (bool, Option<Option<P<Type>>>) | rust:checker_07.rs:999 | Checker
is_const_enum_object_type | pub(crate) fn is_const_enum_object_type(t: P<Type>) -> bool | checker.go:28134 | -
is_const_enum_or_const_enum_only_module | pub(crate) fn is_const_enum_or_const_enum_only_module(s: P<Symbol>) -> bool | emitresolver.go:693 | -
is_const_enum_symbol | pub(crate) fn is_const_enum_symbol(symbol: P<Symbol>) -> bool | checker.go:28138 | -
is_const_type_reference | pub(crate) fn is_const_type_reference(node: P<Node>) -> bool | utilities.go:127 | -
is_const_type_reference_name | pub(crate) fn is_const_type_reference_name(node: Option<P<Node>>) -> bool | utilities.go:133 | -
is_const_type_variable | pub(crate) fn is_const_type_variable(&mut self, t: Option<P<Type>>, depth: u32) -> bool | checker.go:13880 | Checker
is_constant_reference | pub(crate) fn is_constant_reference(&mut self, node: P<Node>) -> bool | flow.go:1814 | Checker
is_constant_reference_of_walk | fn is_constant_reference_of_walk(&mut self, f: P<FlowState>) -> bool | rust:flow.rs:677 | Checker
is_constant_variable | pub(crate) fn is_constant_variable(&mut self, symbol: P<Symbol>) -> bool | utilities.go:1083 | Checker
is_constraint_position | pub(crate) fn is_constraint_position(&mut self, t: P<Type>, node: P<Node>) -> bool | checker.go:31998 | Checker
is_constructed_by | pub(crate) fn is_constructed_by(&mut self, source: P<Type>, target: P<Type>) -> bool | flow.go:794 | Checker
is_constructor_declared_this_property | pub(crate) fn is_constructor_declared_this_property(&mut self, symbol: P<Symbol>) -> (thisAssignmentDeclarationKind, Option<P<Node>>) | checker.go:18531 | Checker
is_constructor_type | pub(crate) fn is_constructor_type(&mut self, t: P<Type>) -> bool | checker.go:17337 | Checker
is_contained_by_namespace | pub(crate) fn is_contained_by_namespace(node: P<Node>) -> bool | checker.go:5740 | -
is_context_sensitive | pub fn is_context_sensitive(&mut self, node: P<Node>) -> bool | checker.go:31386 | Checker
is_context_sensitive_exported | pub fn is_context_sensitive_exported(&mut self, node: P<Node>) -> bool | exports.go:350 | Checker
is_context_sensitive_function_like_declaration | pub(crate) fn is_context_sensitive_function_like_declaration(&mut self, node: P<Node>) -> bool | checker.go:31420 | Checker
is_context_sensitive_function_or_object_literal_method | pub(crate) fn is_context_sensitive_function_or_object_literal_method(&mut self, fn_: P<Node>) -> bool | checker.go:29985 | Checker
is_conversion_or_interface_implementation_message | pub(crate) fn is_conversion_or_interface_implementation_message(message: &'static Message) -> bool | relater.go:4967 | -
is_declaration_contained_by | pub(crate) fn is_declaration_contained_by(symbol: P<Symbol>, container: P<Symbol>) -> bool | checker.go:22472 | Checker
is_declaration_readonly | pub(crate) fn is_declaration_readonly(declaration: P<Node>) -> bool | utilities.go:871 | -
is_declaration_used | pub fn is_declaration_used(&mut self, source_file: P<SourceFile>, identifier: P<Node>, jsx_elements_present: bool, jsx_mode_needs_explicit_import: bool) -> bool | services.go:524 | Checker
is_declaration_visible | pub(crate) fn is_declaration_visible(&self, c: &mut Checker, node: Option<P<Node>>) -> bool | emitresolver.go:111 | EmitResolver
is_declaration_visible_exported | pub fn is_declaration_visible_exported(&self, c: &mut Checker, node: P<Node>) -> bool | emitresolver.go:104 | EmitResolver
is_declaration_with_explicit_type_annotation | pub(crate) fn is_declaration_with_explicit_type_annotation(node: P<Node>) -> bool | flow.go:2197 | Checker
is_deeply_nested_on_stack | pub(crate) fn is_deeply_nested_on_stack(&mut self, t: P<Type>, stack: &[RelaterStackEntry], max_depth: usize) -> bool | rust:relater_1.rs:1153 | Checker
is_deeply_nested_on_stack_walk | fn is_deeply_nested_on_stack_walk(&mut self, t: P<Type>, stack: &[RelaterStackEntry], max_depth: usize) -> bool | rust:relater_1.rs:1157 | Checker
is_deeply_nested_on_stack_walk_kept | fn is_deeply_nested_on_stack_walk_kept(&mut self, t: P<Type>, stack: &[RelaterStackEntry], max_depth: usize) -> bool | rust:relater_1.rs:1175 | Checker
is_deeply_nested_type | pub(crate) fn is_deeply_nested_type(&mut self, t: P<Type>, stack: &[P<Type>], max_depth: usize) -> bool | relater.go:766 | Checker
is_default_binding_context | pub(crate) fn is_default_binding_context(location: P<Node>) -> bool | nodebuilderimpl.go:932 | -
is_deferred_type | pub(crate) fn is_deferred_type(&mut self, t: P<Type>, check_tuples: bool) -> bool | checker.go:24945 | Checker
is_deferred_type_reference_node | pub(crate) fn is_deferred_type_reference_node(&mut self, node: P<Node>, has_default_type_arguments: bool) -> bool | checker.go:23697 | Checker
is_definitely_reference_to_global_symbol_object | pub fn is_definitely_reference_to_global_symbol_object(&self, c: &mut Checker, node: P<Node>) -> bool | emitresolver.go:544 | EmitResolver
is_delete_target | pub(crate) fn is_delete_target(node: P<Node>) -> bool | utilities.go:109 | -
is_deprecated_declaration | pub fn is_deprecated_declaration(&mut self, declaration: P<Node>) -> bool | checker.go:14269 | Checker
is_deprecated_symbol | pub fn is_deprecated_symbol(&mut self, symbol: P<Symbol>) -> bool | checker.go:14289 | Checker
is_destructuring_assignment_target | pub(crate) fn is_destructuring_assignment_target(parent: P<Node>) -> bool | flow.go:2384 | Checker
is_discriminant_property | pub(crate) fn is_discriminant_property(&mut self, t: Option<P<Type>>, name: &str) -> bool | relater.go:1080 | Checker
is_discriminant_with_never_type | pub(crate) fn is_discriminant_with_never_type(&mut self, prop: P<Symbol>) -> bool | checker.go:22278 | Checker
is_distributed_type_parameter | pub fn is_distributed_type_parameter(t: P<Type>) -> bool | exports.go:398 | -
is_distribution_dependent | pub(crate) fn is_distribution_dependent(&mut self, root: P<ConditionalRoot>) -> bool | relater.go:5026 | Checker
is_empty | pub fn is_empty(&self) -> bool | rust:types.rs:130 | GoMap
is_empty | pub fn is_empty(&self) -> bool | rust:packedmap.rs:172 | GoPackedMap
is_empty | pub fn is_empty(&self) -> bool | rust:checker.rs:566 | LazyVec
is_empty | pub fn is_empty(&self) -> bool | rust:packedmap.rs:102 | PackedMap
is_empty | pub fn is_empty(&self) -> bool | rust:packedmap.rs:231 | StringLiteralTypes
is_empty_anonymous_object_type | pub fn is_empty_anonymous_object_type(&mut self, t: P<Type>) -> bool | checker.go:26946 | Checker
is_empty_anonymous_object_type_worker | fn is_empty_anonymous_object_type_worker(&mut self, t: P<Type>) -> bool | rust:checker_13.rs:1073 | Checker
is_empty_array_assignment | pub(crate) fn is_empty_array_assignment(node: P<Node>) -> bool | flow.go:283 | Checker
is_empty_array_literal | pub(crate) fn is_empty_array_literal(expression: P<Node>) -> bool | utilities.go:329 | -
is_empty_array_literal_type | pub(crate) fn is_empty_array_literal_type(&mut self, t: P<Type>) -> bool | checker.go:23993 | Checker
is_empty_literal_type | pub(crate) fn is_empty_literal_type(&self, t: P<Type>) -> bool | checker.go:23998 | Checker
is_empty_object_type | pub(crate) fn is_empty_object_type(&mut self, t: P<Type>) -> bool | checker.go:26955 | Checker
is_empty_object_type_or_spreads_into_empty_object | pub(crate) fn is_empty_object_type_or_spreads_into_empty_object(&mut self, t: P<Type>) -> bool | checker.go:13822 | Checker
is_empty_resolved_type | pub(crate) fn is_empty_resolved_type(&self, t: &'static StructuredType) -> bool | checker.go:26951 | Checker
is_empty_structured_type | pub(crate) fn is_empty_structured_type(&mut self, t: P<Type>) -> bool | rust:checker_13.rs:1085 | Checker
is_entity_name_visible | pub(crate) fn is_entity_name_visible(&self, c: &mut Checker, entity_name: P<Node>, enclosing_declaration: Option<P<Node>>, should_compute_alias_to_make_visible: bool) -> SymbolAccessibilityResult | emitresolver.go:340 | EmitResolver
is_entity_name_visible_exported | pub fn is_entity_name_visible_exported(&self, c: &mut Checker, entity_name: P<Node>, enclosing_declaration: Option<P<Node>>) -> SymbolAccessibilityResult | emitresolver.go:334 | EmitResolver
is_enum_literal | pub fn is_enum_literal(&self) -> bool | rust:types.rs:1737 | Type
is_enum_type_related_to | pub(crate) fn is_enum_type_related_to(&mut self, source: P<Symbol>, target: P<Symbol>, error_reporter: Option<ErrorReporter<'_>>) -> bool | relater.go:281 | Checker
is_error_type | pub(crate) fn is_error_type(&self, t: P<Type>) -> bool | checker.go:27108 | Checker
is_es2015_or_later_constructor_name | pub(crate) fn is_es2015_or_later_constructor_name(s: &str) -> bool | checker.go:1745 | -
is_es2015_or_later_iterable | pub(crate) fn is_es2015_or_later_iterable(n: &str) -> bool | checker.go:6898 | -
is_esm_format_import_importing_commonjs_format_file | pub(crate) fn is_esm_format_import_importing_commonjs_format_file(usage_mode: ModuleKind, target_mode: ModuleKind) -> bool | checker.go:15951 | -
is_evolving_array_operation_target | pub(crate) fn is_evolving_array_operation_target(&mut self, node: P<Node>) -> bool | flow.go:1542 | Checker
is_evolving_array_type_list | pub(crate) fn is_evolving_array_type_list(types: &[P<Type>]) -> bool | flow.go:1527 | -
is_exact_optional_property_mismatch | pub(crate) fn is_exact_optional_property_mismatch(&mut self, source: Option<P<Type>>, target: Option<P<Type>>) -> bool | checker.go:13334 | Checker
is_excess_property_check_target | pub(crate) fn is_excess_property_check_target(t: P<Type>) -> bool | relater.go:747 | -
is_exclamation_token | pub(crate) fn is_exclamation_token(node: Option<P<Node>>) -> bool | utilities.go:294 | -
is_excluded_mapped_property_name | pub(crate) fn is_excluded_mapped_property_name(&mut self, t: P<Type>, property_name_type: P<Type>) -> bool | checker.go:31113 | Checker
is_exhaustive_switch_statement | pub(crate) fn is_exhaustive_switch_statement(&mut self, node: P<Node>) -> bool | flow.go:1933 | Checker
is_expandable_type | pub(crate) fn is_expandable_type(c: &Checker, t: P<Type>, is_alias: bool) -> bool | nodebuilderimpl.go:175 | NodeBuilderImpl
is_expanding | pub(crate) fn is_expanding(ctx: P<NodeBuilderContext>) -> bool | nodebuilder_hover.go:16 | -
is_expando_function_declaration | pub fn is_expando_function_declaration(&self, c: &mut Checker, node: P<Node>) -> bool | emitresolver.go:675 | EmitResolver
is_expando_function_declaration_unsafe | pub fn is_expando_function_declaration_unsafe(&self, c: &mut Checker, node: P<Node>) -> bool | emitresolver.go:660 | EmitResolver
is_expando_property_function_with_return_type_annotation | pub(crate) fn is_expando_property_function_with_return_type_annotation(node: P<Node>) -> bool | flow.go:2202 | Checker
is_exponentiation_operator | pub(crate) fn is_exponentiation_operator(kind: Kind) -> bool | utilities.go:800 | -
is_export_assignment_expression_name | pub(crate) fn is_export_assignment_expression_name(node: Option<P<Node>>) -> bool | utilities.go:143 | -
is_export_or_export_expression | pub(crate) fn is_export_or_export_expression(location: P<Node>) -> bool | checker.go:28826 | -
is_export_specifier_alias | pub(crate) fn is_export_specifier_alias(reference_location: P<Node>, export_specifier: P<Node>) -> bool | services.go:633 | -
is_external_module_symbol | pub fn is_external_module_symbol(module_symbol: P<Symbol>) -> bool | utilities.go:1708 | -
is_false_expression | pub(crate) fn is_false_expression(expr: P<Node>) -> bool | flow.go:2589 | Checker
is_flow_memo_checkpoint | fn is_flow_memo_checkpoint(flow: P<FlowNode>) -> bool | rust:flow.rs:53 | -
is_for_in_variable_for_numeric_property_names | pub(crate) fn is_for_in_variable_for_numeric_property_names(&mut self, expr: P<Node>) -> bool | checker.go:8351 | Checker
is_fresh_literal_type | pub(crate) fn is_fresh_literal_type(t: P<Type>) -> bool | checker.go:25771 | -
is_from_inference_blocked_source | pub(crate) fn is_from_inference_blocked_source(&self, t: P<Type>) -> bool | inference.go:1618 | Checker
is_function_object_type | pub(crate) fn is_function_object_type(&mut self, t: P<Type>) -> bool | checker.go:31629 | Checker
is_function_type | pub(crate) fn is_function_type(&mut self, t: P<Type>) -> bool | checker.go:17333 | Checker
is_generic_function_returning_function | pub(crate) fn is_generic_function_returning_function(&mut self, signature: P<Signature>) -> bool | checker.go:10213 | Checker
is_generic_index_type | pub(crate) fn is_generic_index_type(&mut self, t: P<Type>) -> bool | checker.go:25346 | Checker
is_generic_mapped_type | pub(crate) fn is_generic_mapped_type(&mut self, t: P<Type>) -> bool | checker.go:25378 | Checker
is_generic_mapped_type_worker | fn is_generic_mapped_type_worker(&mut self, t: P<Type>) -> bool | rust:checker_12.rs:1808 | Checker
is_generic_object_type | pub(crate) fn is_generic_object_type(&mut self, t: P<Type>) -> bool | checker.go:25342 | Checker
is_generic_reducible_type | pub(crate) fn is_generic_reducible_type(&mut self, t: P<Type>) -> bool | checker.go:25402 | Checker
is_generic_string_like_type | pub(crate) fn is_generic_string_like_type(&mut self, t: P<Type>) -> bool | checker.go:26993 | Checker
is_generic_tuple_type | pub(crate) fn is_generic_tuple_type(t: P<Type>) -> bool | checker.go:23958 | -
is_generic_tuple_type | pub(crate) fn is_generic_tuple_type(t: P<Type>) -> bool | checker.go:25374 | Checker
is_generic_type | pub(crate) fn is_generic_type(&mut self, t: P<Type>) -> bool | checker.go:25338 | Checker
is_generic_type_with_undefined_constraint | pub(crate) fn is_generic_type_with_undefined_constraint(&mut self, t: P<Type>) -> bool | checker.go:32050 | Checker
is_generic_type_with_union_constraint | pub(crate) fn is_generic_type_with_union_constraint(&mut self, t: P<Type>) -> bool | checker.go:32008 | Checker
is_generic_type_without_nullable_constraint | pub(crate) fn is_generic_type_without_nullable_constraint(&mut self, t: P<Type>) -> bool | checker.go:32015 | Checker
is_global_nan | pub(crate) fn is_global_nan(&mut self, expr: P<Node>) -> bool | checker.go:13061 | Checker
is_global_symbol_constructor | pub(crate) fn is_global_symbol_constructor(&mut self, node: P<Node>) -> bool | checker.go:18576 | Checker
is_hash_private | pub(crate) fn is_hash_private(s: P<Symbol>) -> bool | nodebuilder_hover.go:603 | -
is_homomorphic_mapped_type_with_non_homomorphic_instantiation | pub(crate) fn is_homomorphic_mapped_type_with_non_homomorphic_instantiation(c: &mut Checker, mapped: P<Type>) -> bool | nodebuilderimpl.go:1526 | NodeBuilderImpl
is_hyphenated_jsx_name | pub(crate) fn is_hyphenated_jsx_name(name: &str) -> bool | relater.go:743 | -
is_identifier_that_starts_with_underscore | pub(crate) fn is_identifier_that_starts_with_underscore(node: P<Node>) -> bool | checker.go:7439 | -
is_identifier_type_reference | pub(crate) fn is_identifier_type_reference(node: P<Node>) -> bool | nodebuilderimpl.go:463 | -
is_ignored_jsx_property | pub(crate) fn is_ignored_jsx_property(source: P<Type>, source_prop: P<Symbol>) -> bool | relater.go:2859 | -
is_immediately_used_in_initializer_of_block_scoped_variable | pub(crate) fn is_immediately_used_in_initializer_of_block_scoped_variable(declaration: P<Node>, usage: P<Node>, decl_container: P<Node>) -> bool | checker.go:2113 | -
is_implementation_compatible_with_overload | pub(crate) fn is_implementation_compatible_with_overload(&mut self, implementation: P<Signature>, overload: P<Signature>) -> bool | checker.go:3744 | Checker
is_implementation_of_overload | pub fn is_implementation_of_overload(&self, c: &mut Checker, node: P<Node>) -> bool | emitresolver.go:467 | EmitResolver
is_import_required_by_augmentation | pub fn is_import_required_by_augmentation(&self, c: &mut Checker, decl: P<Node>) -> bool | emitresolver.go:508 | EmitResolver
is_import_type_qualifier_part | pub(crate) fn is_import_type_qualifier_part(node: P<Node>) -> Option<P<Node>> | utilities.go:1174 | -
is_in_ambient_or_type_node | pub(crate) fn is_in_ambient_or_type_node(node: P<Node>) -> bool | utilities.go:1101 | -
is_in_ambient_or_type_node | pub(crate) fn is_in_ambient_or_type_node(node: P<Node>) -> bool | checker.go:11438 | Checker
is_in_compound_like_assignment | pub(crate) fn is_in_compound_like_assignment(node: P<Node>) -> bool | utilities.go:117 | -
is_in_constructor_argument_initializer | pub(crate) fn is_in_constructor_argument_initializer(node: P<Node>, constructor_decl: P<Node>) -> bool | checker.go:8136 | Checker
is_in_name_of_expression_with_type_arguments_or_heritage_type_reference | pub(crate) fn is_in_name_of_expression_with_type_arguments_or_heritage_type_reference(node: P<Node>) -> bool | utilities.go:1188 | -
is_in_parameter_initializer_before_containing_function | pub(crate) fn is_in_parameter_initializer_before_containing_function(node: P<Node>) -> bool | checker.go:12438 | Checker
is_in_property_initializer_or_class_static_block | pub(crate) fn is_in_property_initializer_or_class_static_block(node: P<Node>, ignore_arrow_functions: bool) -> bool | checker.go:13941 | Checker
is_in_right_side_of_import_or_export_assignment | pub(crate) fn is_in_right_side_of_import_or_export_assignment(node: P<Node>) -> bool | utilities.go:1150 | -
is_in_type_query | pub fn is_in_type_query(node: P<Node>) -> bool | utilities.go:168 | -
is_index | pub fn is_index(&self) -> bool | rust:types.rs:1762 | Type
is_indirect_call | pub(crate) fn is_indirect_call(node: P<Node>) -> bool | checker.go:13247 | Checker
is_initializer_big_int_literal_expression | pub(crate) fn is_initializer_big_int_literal_expression(expr: P<Node>) -> bool | grammarchecks.go:1965 | -
is_initializer_simple_literal_enum_reference | pub(crate) fn is_initializer_simple_literal_enum_reference(&mut self, expr: P<Node>) -> bool | grammarchecks.go:1978 | Checker
is_initializer_string_or_number_literal_expression | pub(crate) fn is_initializer_string_or_number_literal_expression(expr: P<Node>) -> bool | grammarchecks.go:1960 | -
is_inline_import_attributes | pub(crate) fn is_inline_import_attributes(node: P<Node>) -> bool | checker.go:13842 | Checker
is_instance_property_with_initializer_or_private_identifier_property | pub(crate) fn is_instance_property_with_initializer_or_private_identifier_property(n: P<Node>) -> bool | checker.go:2952 | -
is_instantiated_generic_parameter | pub(crate) fn is_instantiated_generic_parameter(&mut self, signature: P<Signature>, pos: usize) -> bool | relater.go:1954 | Checker
is_instantiated_module | pub(crate) fn is_instantiated_module(node: P<Node>, preserve_const_enums: bool) -> bool | checker.go:5352 | -
is_interface_check_site | fn is_interface_check_site(&mut self, symbol: P<Symbol>, node: P<Node>) -> bool | rust:checker_03.rs:979 | Checker
is_internal_module_import_equals_declaration | pub(crate) fn is_internal_module_import_equals_declaration(node: P<Node>) -> bool | checker.go:28862 | -
is_intersection | pub fn is_intersection(&self) -> bool | rust:types.rs:1717 | Type
is_intersection_data | fn is_intersection_data(&self) -> bool | rust:types.rs:2570 | UnionOrIntersectionType
is_intersection_empty | pub(crate) fn is_intersection_empty(&mut self, type1: P<Type>, type2: P<Type>) -> bool | checker.go:28499 | Checker
is_intersection_type | pub(crate) fn is_intersection_type(t: P<Type>) -> bool | checker.go:26703 | -
is_invalid_computed_property_name | pub(crate) fn is_invalid_computed_property_name(node: P<Node>) -> bool | checker.go:27266 | -
is_iterator_result | pub(crate) fn is_iterator_result(&mut self, t: P<Type>, kind: IterationTypeKind) -> bool | checker.go:6860 | Checker
is_js_literal_type | pub(crate) fn is_js_literal_type(&mut self, t: P<Type>) -> bool | utilities.go:1807 | Checker
is_jsx_intrinsic_tag_name | pub(crate) fn is_jsx_intrinsic_tag_name(tag_name: P<Node>) -> bool | utilities.go:1159 | -
is_key_type_included | pub(crate) fn is_key_type_included(key_type: P<Type>, include: TypeFlags) -> bool | checker.go:27259 | Checker
is_known_generic_type_name | pub(crate) fn is_known_generic_type_name(name: &str) -> bool | services.go:1004 | -
is_known_property | pub(crate) fn is_known_property(&mut self, target_type: P<Type>, name: &str, is_comparing_jsx_attributes: bool) -> bool | relater.go:717 | Checker
is_known_symbol | pub fn is_known_symbol(symbol: P<Symbol>) -> bool | utilities.go:1018 | -
is_late_bindable_ast | pub(crate) fn is_late_bindable_ast(node: P<Node>) -> bool | checker.go:20331 | -
is_late_bindable_index_signature | pub(crate) fn is_late_bindable_index_signature(&mut self, node: P<Node>) -> bool | checker.go:20317 | Checker
is_late_bindable_name | pub(crate) fn is_late_bindable_name(&mut self, node: P<Node>) -> bool | checker.go:20302 | Checker
is_late_bound | pub fn is_late_bound(&self, c: &mut Checker, node: Option<P<Node>>) -> bool | emitresolver.go:71 | EmitResolver
is_late_bound_name | pub(crate) fn is_late_bound_name(name: &str) -> bool | utilities.go:1029 | -
is_lib_symbol_for_hover_verbosity | pub fn is_lib_symbol_for_hover_verbosity(&self, symbol: Option<P<Symbol>>) -> bool | services.go:1125 | Checker
is_lib_type_for_hover_verbosity | pub fn is_lib_type_for_hover_verbosity(&self, t: P<Type>) -> bool | services.go:1140 | Checker
is_literal_const_declaration | pub fn is_literal_const_declaration(&self, c: &mut Checker, node: P<Node>) -> bool | emitresolver.go:643 | EmitResolver
is_literal_expression_of_object | pub(crate) fn is_literal_expression_of_object(node: P<Node>) -> bool | utilities.go:1107 | -
is_literal_of_contextual_type | pub(crate) fn is_literal_of_contextual_type(&mut self, candidate_type: P<Type>, contextual_type: Option<P<Type>>) -> bool | checker.go:25992 | Checker
is_literal_type | pub(crate) fn is_literal_type(t: P<Type>) -> bool | checker.go:25863 | -
is_local_type_alias | pub(crate) fn is_local_type_alias(symbol: P<Symbol>) -> bool | checker.go:24126 | -
is_mapped_type_generic_indexed_access | pub(crate) fn is_mapped_type_generic_indexed_access(&mut self, t: P<Type>) -> bool | checker.go:22077 | Checker
is_mapped_type_homomorphic | pub(crate) fn is_mapped_type_homomorphic(c: &mut Checker, mapped: P<Type>) -> bool | nodebuilderimpl.go:1522 | NodeBuilderImpl
is_mapped_type_with_keyof_constraint_declaration | pub(crate) fn is_mapped_type_with_keyof_constraint_declaration(t: P<Type>) -> bool | checker.go:23134 | Checker
is_mapping_of_same_object_type | pub(crate) fn is_mapping_of_same_object_type(&mut self, types: &[P<Type>]) -> bool | checker.go:22206 | Checker
is_marker_type | pub(crate) fn is_marker_type(&self, t: P<Type>) -> bool | relater.go:1462 | Checker
is_matching_constructor_reference | pub(crate) fn is_matching_constructor_reference(&mut self, f: P<FlowState>, expr: P<Node>) -> bool | flow.go:750 | Checker
is_matching_reference | pub(crate) fn is_matching_reference(&mut self, source: P<Node>, target: P<Node>) -> bool | flow.go:1597 | Checker
is_matching_signature | pub(crate) fn is_matching_signature(&mut self, source: P<Signature>, target: P<Signature>, partial_match: bool) -> bool | relater.go:2260 | Checker
is_member_of_string_mapping | pub(crate) fn is_member_of_string_mapping(&mut self, source: P<Type>, target: P<Type>) -> bool | relater.go:2531 | Checker
is_message | fn is_message(message: Option<&'static Message>, target: &'static Message) -> bool | rust:relater_2.rs:12 | -
is_method_access_for_call | pub(crate) fn is_method_access_for_call(node: P<Node>) -> bool | checker.go:11667 | Checker
is_mixin_constructor_type | pub(crate) fn is_mixin_constructor_type(&mut self, t: P<Type>) -> bool | checker.go:17350 | Checker
is_multiplicative_operator | pub(crate) fn is_multiplicative_operator(kind: Kind) -> bool | utilities.go:804 | -
is_multiplicative_operator_or_higher | pub(crate) fn is_multiplicative_operator_or_higher(kind: Kind) -> bool | utilities.go:808 | -
is_mutable_array_like_type | pub(crate) fn is_mutable_array_like_type(&mut self, t: P<Type>) -> bool | checker.go:23987 | Checker
is_mutable_array_or_tuple | pub(crate) fn is_mutable_array_or_tuple(&self, t: P<Type>) -> bool | checker.go:23970 | Checker
is_mutable_local_variable_declaration | pub(crate) fn is_mutable_local_variable_declaration(declaration: P<Node>) -> bool | utilities.go:1096 | Checker
is_mutable_tuple_type | pub(crate) fn is_mutable_tuple_type(t: P<Type>) -> bool | checker.go:23954 | -
is_name_resolvable | pub fn is_name_resolvable(&self, c: &mut Checker, location: Option<P<Node>>, name: &str) -> bool | emitresolver.go:916 | EmitResolver
is_named_member | pub(crate) fn is_named_member(&mut self, symbol: P<Symbol>, id: &str) -> bool | checker.go:22483 | Checker
is_namespace_member | pub(crate) fn is_namespace_member(_c: &mut Checker, p: P<Symbol>) -> bool | nodebuilder_hover.go:598 | NodeBuilderImpl
is_namespace_reexport_declaration | pub(crate) fn is_namespace_reexport_declaration(node: P<Node>) -> bool | symbolaccessibility.go:616 | -
is_neither_unit_type_nor_never | pub(crate) fn is_neither_unit_type_nor_never(t: P<Type>) -> bool | checker.go:25876 | -
is_never_reduced_property | pub(crate) fn is_never_reduced_property(&mut self, prop: P<Symbol>) -> bool | checker.go:22252 | Checker
is_nil | pub(crate) fn is_nil(self) -> bool | flow.go:24 | FlowType
is_nil | pub fn is_nil(&self) -> bool | rust:types.rs:94 | GoMap
is_nil | pub fn is_nil(&self) -> bool | rust:packedmap.rs:139 | GoPackedMap
is_no_infer_target_type | pub(crate) fn is_no_infer_target_type(&mut self, t: P<Type>) -> bool | checker.go:27871 | Checker
is_no_infer_type | pub(crate) fn is_no_infer_type(t: P<Type>) -> bool | checker.go:27292 | Checker
is_node_descendant_of | pub(crate) fn is_node_descendant_of(node: Option<P<Node>>, ancestor: P<Node>) -> bool | utilities.go:912 | -
is_node_used_during_class_initialization | pub(crate) fn is_node_used_during_class_initialization(node: P<Node>) -> bool | checker.go:12152 | Checker
is_node_within_class | pub(crate) fn is_node_within_class(&mut self, node: P<Node>, class_declaration: P<Node>) -> bool | checker.go:12163 | Checker
is_non_bindable_dynamic_name | pub(crate) fn is_non_bindable_dynamic_name(&mut self, node: P<Node>) -> bool | grammarchecks.go:1410 | Checker
is_non_deferred_type_reference | pub fn is_non_deferred_type_reference(t: P<Type>) -> bool | checker.go:17986 | -
is_non_generic_object_type | pub(crate) fn is_non_generic_object_type(&mut self, t: P<Type>) -> bool | checker.go:13744 | Checker
is_non_generic_top_level_type | pub(crate) fn is_non_generic_top_level_type(t: P<Type>) -> bool | checker.go:22626 | Checker
is_non_null_access | pub(crate) fn is_non_null_access(node: P<Node>) -> bool | utilities.go:1120 | -
is_non_primitive_type | pub(crate) fn is_non_primitive_type(t: P<Type>) -> bool | relater.go:1266 | -
is_none | pub fn is_none(self) -> bool | rust:types.rs:1161 | AliasArg
is_not_null_type | pub(crate) fn is_not_null_type(t: P<Type>) -> bool | checker.go:26715 | -
is_not_overload | pub(crate) fn is_not_overload(node: P<Node>) -> bool | checker.go:5921 | -
is_not_replacable_by_method | pub(crate) fn is_not_replacable_by_method(decl: P<Node>) -> bool | checker.go:16412 | -
is_not_undefined_type | pub(crate) fn is_not_undefined_type(t: P<Type>) -> bool | checker.go:26711 | -
is_null_or_undefined | pub(crate) fn is_null_or_undefined(&mut self, node: P<Node>) -> bool | checker.go:18007 | Checker
is_nullable_type | pub fn is_nullable_type(&mut self, t: P<Type>) -> bool | checker.go:19014 | Checker
is_number_literal | pub fn is_number_literal(&self) -> bool | rust:types.rs:1727 | Type
is_numeric_computed_name | pub(crate) fn is_numeric_computed_name(&mut self, name: P<Node>) -> bool | checker.go:20122 | Checker
is_numeric_literal_name | pub(crate) fn is_numeric_literal_name(name: &str) -> bool | utilities.go:941 | -
is_numeric_name | pub(crate) fn is_numeric_name(&mut self, name: P<Node>) -> bool | checker.go:20112 | Checker
is_object_literal_type | pub(crate) fn is_object_literal_type(t: P<Type>) -> bool | utilities.go:867 | -
is_object_or_array_literal_type | pub(crate) fn is_object_or_array_literal_type(t: P<Type>) -> bool | utilities.go:1033 | -
is_object_or_instantiable_non_primitive | pub(crate) fn is_object_or_instantiable_non_primitive(t: P<Type>) -> bool | relater.go:1148 | -
is_object_type_with_inferable_index | pub(crate) fn is_object_type_with_inferable_index(&mut self, t: P<Type>) -> bool | relater.go:4656 | Checker
is_only_importable_as_default | pub(crate) fn is_only_importable_as_default(&mut self, usage: P<Node>, resolved_module: Option<P<Symbol>>, import_attributes_type: Option<P<Type>>) -> bool | checker.go:15043 | Checker
is_optional_declaration | pub(crate) fn is_optional_declaration(declaration: P<Node>) -> bool | utilities.go:298 | -
is_optional_parameter | pub(crate) fn is_optional_parameter(&mut self, node: P<Node>) -> bool | utilities.go:302 | Checker
is_optional_parameter | pub(crate) fn is_optional_parameter(&self, c: &mut Checker, node: P<Node>) -> bool | emitresolver.go:639 | EmitResolver
is_optional_parameter_exported | pub fn is_optional_parameter_exported(&self, c: &mut Checker, node: P<Node>) -> bool | emitresolver.go:65 | EmitResolver
is_optional_property_declaration | pub(crate) fn is_optional_property_declaration(node: P<Node>) -> bool | checker.go:11933 | Checker
is_optional_uninitialized_parameter_property | pub(crate) fn is_optional_uninitialized_parameter_property(&self, c: &mut Checker, parameter: P<Node>) -> bool | emitresolver.go:622 | EmitResolver
is_or_contains_matching_reference | pub(crate) fn is_or_contains_matching_reference(&mut self, source: P<Node>, target: P<Node>) -> bool | flow.go:1898 | Checker
is_or_has_generic_conditional | pub(crate) fn is_or_has_generic_conditional(t: P<Type>) -> bool | relater.go:474 | Checker
is_parameter_of_context_sensitive_signature | pub(crate) fn is_parameter_of_context_sensitive_signature(&mut self, symbol: P<Symbol>) -> bool | checker.go:16887 | Checker
is_parameter_or_mutable_local_variable | pub(crate) fn is_parameter_or_mutable_local_variable(symbol: P<Symbol>) -> bool | utilities.go:1087 | Checker
is_part_of_import_equals_module_reference | pub(crate) fn is_part_of_import_equals_module_reference(location: P<Node>) -> bool | checker.go:28949 | -
is_partial_mapped_type | pub(crate) fn is_partial_mapped_type(t: P<Type>) -> bool | checker.go:29530 | -
is_partially_inferable_type | pub(crate) fn is_partially_inferable_type(&mut self, t: P<Type>) -> bool | inference.go:1060 | Checker
is_past_last_assignment | pub(crate) fn is_past_last_assignment(&mut self, symbol: P<Symbol>, location: Option<P<Node>>) -> bool | flow.go:2668 | Checker
is_pattern_literal_placeholder_type | pub(crate) fn is_pattern_literal_placeholder_type(&mut self, t: P<Type>) -> bool | checker.go:26969 | Checker
is_pattern_literal_type | pub(crate) fn is_pattern_literal_type(&mut self, t: P<Type>) -> bool | checker.go:26986 | Checker
is_possibly_discriminant_value | pub(crate) fn is_possibly_discriminant_value(node: P<Node>) -> bool | checker.go:31291 | Checker
is_post_super_flow_node | pub(crate) fn is_post_super_flow_node(&mut self, flow: P<FlowNode>, no_cache_check: bool) -> bool | flow.go:2604 | Checker
is_post_super_flow_node_worker | pub(crate) fn is_post_super_flow_node_worker(&mut self, f: P<FlowState>, flow: P<FlowNode>, no_cache_check: bool) -> bool | flow.go:2611 | Checker
is_potentially_uncalled_decorator | pub(crate) fn is_potentially_uncalled_decorator(&mut self, decorator: P<Node>, signatures: &[P<Signature>]) -> bool | checker.go:8963 | Checker
is_primitive_or_object_or_empty_type | pub(crate) fn is_primitive_or_object_or_empty_type(&mut self, t: P<Type>) -> bool | rust:checker.rs:2431 | Checker
is_primitive_type_name | pub(crate) fn is_primitive_type_name(s: &str) -> bool | checker.go:1678 | -
is_primitive_union | pub(crate) fn is_primitive_union(t: P<Type>) -> bool | checker.go:26707 | -
is_private_identifier_symbol | pub fn is_private_identifier_symbol(symbol: Option<P<Symbol>>) -> bool | utilities.go:1022 | -
is_private_within_ambient | pub(crate) fn is_private_within_ambient(node: P<Node>) -> bool | utilities.go:342 | -
is_promise_resolve_arity_error | pub(crate) fn is_promise_resolve_arity_error(&mut self, node: P<Node>) -> bool | checker.go:10015 | Checker
is_property_abstract_or_interface | pub(crate) fn is_property_abstract_or_interface(declaration: P<Node>, base_declaration_flags: ModifierFlags) -> bool | checker.go:4751 | Checker
is_property_accessible | pub fn is_property_accessible(&mut self, node: P<Node>, is_super: bool, is_write: bool, containing_type: P<Type>, property: P<Symbol>) -> bool | checker.go:11841 | Checker
is_property_accessible_exported | pub fn is_property_accessible_exported(&mut self, node: P<Node>, is_super: bool, is_write: bool, containing_type: P<Type>, property: P<Symbol>) -> bool | exports.go:159 | Checker
is_property_declared_in_ancestor_class | pub(crate) fn is_property_declared_in_ancestor_class(&mut self, prop: P<Symbol>) -> bool | checker.go:11937 | Checker
is_property_identical_to | pub(crate) fn is_property_identical_to(&mut self, source_prop: P<Symbol>, target_prop: P<Symbol>) -> bool | checker.go:5159 | Checker
is_property_immediately_referenced_within_declaration | pub(crate) fn is_property_immediately_referenced_within_declaration(declaration: P<Node>, usage: P<Node>, stop_at_any_property_declaration: bool) -> bool | checker.go:2147 | -
is_property_in_class_derived_from | pub(crate) fn is_property_in_class_derived_from(&mut self, prop: P<Symbol>, base_class: Option<P<Type>>) -> bool | checker.go:12142 | Checker
is_property_initialized_in_constructor | pub(crate) fn is_property_initialized_in_constructor(&mut self, prop_name: P<Node>, prop_type: P<Type>, constructor: P<Node>) -> bool | checker.go:5068 | Checker
is_property_initialized_in_static_blocks | pub(crate) fn is_property_initialized_in_static_blocks(&mut self, prop_name: P<Node>, prop_type: P<Type>, static_blocks: &[P<Node>], start_pos: TextPos, end_pos: TextPos) -> bool | checker.go:5051 | Checker
is_property_or_method_declaration_symbol | pub(crate) fn is_property_or_method_declaration_symbol(symbol: P<Symbol>) -> bool | symbolaccessibility.go:728 | -
is_property_symbol_type_related | pub(crate) fn is_property_symbol_type_related(&self, c: &mut Checker, source_prop: P<Symbol>, target_prop: P<Symbol>, get_type_of_source_property: impl FnMut(&mut Checker, P<Symbol>) -> P<Type>, report_errors: bool, intersection_state: IntersectionState) -> Ternary | relater.go:4366 | Relater
is_property_without_initializer | pub(crate) fn is_property_without_initializer(node: P<Node>) -> bool | checker.go:5047 | Checker
is_prototype_property | pub(crate) fn is_prototype_property(symbol: P<Symbol>) -> bool | checker.go:22037 | -
is_pure | pub fn is_pure(self) -> bool | rust:flowmemo.rs:148 | FrameTaint
is_reachable_flow_node | pub(crate) fn is_reachable_flow_node(&mut self, flow: P<FlowNode>) -> bool | flow.go:2513 | Checker
is_reachable_flow_node_worker | pub(crate) fn is_reachable_flow_node_worker(&mut self, f: P<FlowState>, flow: P<FlowNode>, no_cache_check: bool) -> bool | flow.go:2522 | Checker
is_readonly | pub fn is_readonly(&self) -> bool | rust:types.rs:3163 | IndexInfo
is_readonly | pub fn is_readonly(&self) -> bool | rust:types.rs:2408 | TupleType
is_readonly_array_symbol | pub(crate) fn is_readonly_array_symbol(&mut self, symbol: Option<P<Symbol>>) -> bool | checker.go:21442 | Checker
is_readonly_array_type | pub(crate) fn is_readonly_array_type(&self, t: P<Type>) -> bool | checker.go:23946 | Checker
is_readonly_assignment_declaration | pub(crate) fn is_readonly_assignment_declaration(&mut self, node: P<Node>) -> bool | checker.go:14064 | Checker
is_readonly_symbol | pub fn is_readonly_symbol(&mut self, symbol: P<Symbol>) -> bool | checker.go:14084 | Checker
is_readonly_symbol_exported | pub fn is_readonly_symbol_exported(&mut self, symbol: P<Symbol>) -> bool | exports.go:231 | Checker
is_readonly_symbol_with_modifiers | pub(crate) fn is_readonly_symbol_with_modifiers(&mut self, symbol: P<Symbol>, modifiers: impl FnOnce() -> ModifierFlags) -> bool | rust:checker_07.rs:1371 | Checker
is_readonly_type_operator | pub(crate) fn is_readonly_type_operator(node: P<Node>) -> bool | checker.go:24630 | Checker
is_reducible_intersection | pub(crate) fn is_reducible_intersection(&mut self, t: P<Type>) -> bool | checker.go:25407 | Checker
is_reference_to_some_type | pub(crate) fn is_reference_to_some_type(t: Option<P<Type>>, targets: &[P<Type>]) -> bool | checker.go:6566 | Checker
is_reference_to_type | pub(crate) fn is_reference_to_type(t: Option<P<Type>>, target: P<Type>) -> bool | checker.go:6562 | Checker
is_referenced | pub(crate) fn is_referenced(&self, symbol: P<Symbol>) -> bool | checker.go:7245 | Checker
is_referenced_alias_declaration | pub fn is_referenced_alias_declaration(&self, c: &mut Checker, node: P<Node>) -> bool | emitresolver.go:697 | EmitResolver
is_related_to | pub(crate) fn is_related_to(&self, c: &mut Checker, source: P<Type>, target: P<Type>, recursion_flags: RecursionFlags, report_errors: bool) -> Ternary | relater.go:2629 | Relater
is_related_to_ex | pub(crate) fn is_related_to_ex(&self, c: &mut Checker, original_source: P<Type>, original_target: P<Type>, recursion_flags: RecursionFlags, report_errors: bool, head_message: Option<&'static Message>, intersection_state: IntersectionState) -> Ternary | relater.go:2633 | Relater
is_related_to_simple | pub(crate) fn is_related_to_simple(&self, c: &mut Checker, source: P<Type>, target: P<Type>) -> Ternary | relater.go:2621 | Relater
is_related_to_worker | pub(crate) fn is_related_to_worker(&self, c: &mut Checker, source: P<Type>, target: P<Type>, report_errors: bool) -> Ternary | relater.go:2625 | Relater
is_required_initialized_parameter | pub(crate) fn is_required_initialized_parameter(&self, c: &mut Checker, parameter: P<Node>, enclosing_declaration: Option<P<Node>>) -> bool | emitresolver.go:629 | EmitResolver
is_reserved_member_name | pub(crate) fn is_reserved_member_name(name: &str) -> bool | utilities.go:1677 | -
is_resolved_by_type_alias | pub(crate) fn is_resolved_by_type_alias(node: P<Node>) -> bool | checker.go:23718 | Checker
is_resolving_return_type_of_signature | pub(crate) fn is_resolving_return_type_of_signature(&mut self, signature: P<Signature>) -> bool | relater.go:2145 | Checker
is_rest_parameter | pub(crate) fn is_rest_parameter(param: P<Node>) -> bool | checker.go:28262 | -
is_return_iterator_result | pub(crate) fn is_return_iterator_result(&mut self, t: P<Type>) -> bool | checker.go:6856 | Checker
is_right_side_of_access_expression | pub(crate) fn is_right_side_of_access_expression(node: P<Node>) -> bool | utilities.go:240 | -
is_same_scope_descendent_of | pub(crate) fn is_same_scope_descendent_of(initial: P<Node>, parent: Option<P<Node>>, stop_at: P<Node>) -> bool | checker.go:2131 | -
is_same_scoped_binding_element | pub(crate) fn is_same_scoped_binding_element(node: P<Node>, declaration: P<Node>) -> bool | checker.go:11402 | Checker
is_self_type_access | pub(crate) fn is_self_type_access(&mut self, name: P<Node>, parent: Option<P<Symbol>>) -> bool | checker.go:27745 | Checker
is_shift_operator | pub(crate) fn is_shift_operator(kind: Kind) -> bool | utilities.go:820 | -
is_shift_operator_or_higher | pub(crate) fn is_shift_operator_or_higher(kind: Kind) -> bool | utilities.go:825 | -
is_shorthand_ambient_module | pub(crate) fn is_shorthand_ambient_module(node: Option<P<Node>>) -> bool | utilities.go:201 | -
is_shorthand_ambient_module_symbol | pub(crate) fn is_shorthand_ambient_module_symbol(module_symbol: P<Symbol>) -> bool | utilities.go:197 | -
is_side_effect_free | pub(crate) fn is_side_effect_free(node: P<Node>) -> bool | checker.go:13219 | Checker
is_side_effect_import | pub(crate) fn is_side_effect_import(node: P<Node>) -> bool | utilities.go:228 | -
is_signature_applicable | pub(crate) fn is_signature_applicable(&mut self, node: P<Node>, args: &[P<Node>], signature: P<Signature>, relation: P<Relation>, check_mode: CheckMode, report_errors: bool, diagnostic_output: Option<&mut Vec<P<Diagnostic>>>) -> bool | checker.go:9448 | Checker
is_signature_assignable_to | pub(crate) fn is_signature_assignable_to(&mut self, source: P<Signature>, target: P<Signature>, ignore_return_types: bool) -> bool | relater.go:1487 | Checker
is_simple_identifier_type_reference | pub(crate) fn is_simple_identifier_type_reference(node: P<Node>) -> bool | checker.go:23477 | -
is_simple_tuple_type | pub(crate) fn is_simple_tuple_type(node: P<Node>) -> bool | checker.go:24939 | Checker
is_simple_type_related_to | pub(crate) fn is_simple_type_related_to(&mut self, source: P<Type>, target: P<Type>, relation: P<Relation>, error_reporter: Option<ErrorReporter<'_>>) -> bool | relater.go:205 | Checker
is_simple_type_related_to_reporting | fn is_simple_type_related_to_reporting(&self, c: &mut Checker, source: P<Type>, target: P<Type>, report_errors: bool) -> bool | rust:relater_2.rs:63 | Relater
is_single_element_generic_tuple_type | pub(crate) fn is_single_element_generic_tuple_type(t: P<Type>) -> bool | checker.go:23962 | -
is_single_quoted_string_named | pub(crate) fn is_single_quoted_string_named(_c: &mut Checker, d: P<Node>) -> bool | nodebuilderimpl.go:2493 | NodeBuilderImpl
is_skip_direct_inference_node | pub(crate) fn is_skip_direct_inference_node(&self, node: P<Node>) -> bool | inference.go:1622 | Checker
is_skippable_contextual_constituent | fn is_skippable_contextual_constituent(&mut self, t: P<Type>, key: HashedName<'_>) -> bool | rust:checker_15.rs:776 | Checker
is_some_symbol_assigned | pub(crate) fn is_some_symbol_assigned(&mut self, root_declaration: P<Node>) -> bool | checker.go:31960 | Checker
is_some_symbol_assigned_worker | pub(crate) fn is_some_symbol_assigned_worker(&mut self, node: P<Node>) -> bool | checker.go:31964 | Checker
is_sorted_subset | pub(crate) fn is_sorted_subset(source: &[P<Type>], target: &[P<Type>]) -> bool | rust:checker_13.rs:1390 | -
is_source_element_unreachable | pub(crate) fn is_source_element_unreachable(&mut self, node: P<Node>) -> bool | checker.go:2494 | Checker
is_source_intersection_needing_extra_check | pub(crate) fn is_source_intersection_needing_extra_check(c: &mut Checker, source: P<Type>, target: P<Type>) -> bool | relater.go:3286 | Relater
is_spread_argument | pub(crate) fn is_spread_argument(arg: P<Node>) -> bool | checker.go:30601 | -
is_spread_into_call_or_new | pub(crate) fn is_spread_into_call_or_new(node: P<Node>) -> bool | checker.go:8289 | -
is_spreadable_property | pub fn is_spreadable_property(prop: P<Symbol>) -> bool | checker.go:13798 | Checker
is_static_private_identifier_property | pub(crate) fn is_static_private_identifier_property(s: P<Symbol>) -> bool | utilities.go:71 | -
is_string | pub fn is_string(&self) -> bool | rust:types.rs:1712 | Type
is_string_index_signature_only_type | pub(crate) fn is_string_index_signature_only_type(&mut self, t: P<Type>) -> bool | rust:checker.rs:2452 | Checker
is_string_index_signature_only_type_worker | pub(crate) fn is_string_index_signature_only_type_worker(&mut self, t: P<Type>) -> bool | checker.go:27835 | Checker
is_string_like | pub fn is_string_like(&self) -> bool | rust:types.rs:1747 | Type
is_string_literal | pub fn is_string_literal(&self) -> bool | rust:types.rs:1722 | Type
is_string_named | pub(crate) fn is_string_named(c: &mut Checker, d: P<Node>) -> bool | nodebuilderimpl.go:2477 | NodeBuilderImpl
is_structural_pseudo_type | pub(crate) fn is_structural_pseudo_type(t: P<PseudoType>) -> bool | pseudotypenodebuilder.go:632 | -
is_super_call | pub(crate) fn is_super_call(n: P<Node>) -> bool | utilities.go:1136 | -
is_symbol_accessible | pub fn is_symbol_accessible(&mut self, symbol: Option<P<Symbol>>, enclosing_declaration: Option<P<Node>>, meaning: SymbolFlags, should_compute_aliases_to_make_visible: bool) -> SymbolAccessibilityResult | symbolaccessibility.go:839 | Checker
is_symbol_accessible | pub fn is_symbol_accessible(&self, c: &mut Checker, symbol: Option<P<Symbol>>, enclosing_declaration: Option<P<Node>>, meaning: SymbolFlags, should_compute_alias_to_mark_visible: bool) -> SymbolAccessibilityResult | emitresolver.go:681 | EmitResolver
is_symbol_accessible_by_flags | pub fn is_symbol_accessible_by_flags(&mut self, symbol: P<Symbol>, enclosing_declaration: Option<P<Node>>, flags: SymbolFlags) -> bool | symbolaccessibility.go:21 | Checker
is_symbol_accessible_exported | pub fn is_symbol_accessible_exported(&self, c: &mut Checker, symbol: Option<P<Symbol>>, enclosing_declaration: Option<P<Node>>, meaning: SymbolFlags, should_compute_alias_to_mark_visible: bool) -> SymbolAccessibilityResult | emitresolver.go:685 | EmitResolver
is_symbol_accessible_worker | pub(crate) fn is_symbol_accessible_worker(&mut self, symbol: Option<P<Symbol>>, enclosing_declaration: Option<P<Node>>, meaning: SymbolFlags, should_compute_aliases_to_make_visible: bool, allow_modules: bool) -> SymbolAccessibilityResult | symbolaccessibility.go:843 | Checker
is_symbol_assigned | pub(crate) fn is_symbol_assigned(&mut self, symbol: P<Symbol>) -> bool | flow.go:2661 | Checker
is_symbol_assigned_definitely | pub(crate) fn is_symbol_assigned_definitely(&mut self, symbol: P<Symbol>) -> bool | flow.go:2655 | Checker
is_symbol_or_symbol_for_call | pub(crate) fn is_symbol_or_symbol_for_call(&mut self, node: P<Node>) -> bool | checker.go:8555 | Checker
is_symbol_referenced_in_file | pub fn is_symbol_referenced_in_file(&mut self, source_file: P<SourceFile>, definition: P<Node>, symbol: P<Symbol>) -> bool | services.go:552 | Checker
is_symbol_unaffected_by_instantiation | pub(crate) fn is_symbol_unaffected_by_instantiation(&mut self, symbol: P<Symbol>, m: Option<P<TypeMapper>>) -> bool | rust:checker_10.rs:1774 | Checker
is_symbol_used_in_binary_expression_chain | pub(crate) fn is_symbol_used_in_binary_expression_chain(&mut self, node: P<Node>, tested_symbol: P<Symbol>) -> bool | checker.go:3918 | Checker
is_symbol_used_in_condition_body | pub(crate) fn is_symbol_used_in_condition_body(&mut self, expr: P<Node>, body: P<Node>, tested_node: Option<P<Node>>, tested_symbol: P<Symbol>) -> bool | checker.go:3939 | Checker
is_symbol_with_computed_name | pub(crate) fn is_symbol_with_computed_name(symbol: P<Symbol>) -> bool | checker.go:20104 | Checker
is_symbol_with_numeric_name | pub(crate) fn is_symbol_with_numeric_name(&mut self, symbol: P<Symbol>) -> bool | checker.go:20093 | Checker
is_symbol_with_symbol_name | pub(crate) fn is_symbol_with_symbol_name(&mut self, symbol: P<Symbol>) -> bool | checker.go:20082 | Checker
is_syntactic_default | pub(crate) fn is_syntactic_default(node: P<Node>) -> bool | utilities.go:249 | -
is_template_literal_context | pub(crate) fn is_template_literal_context(node: P<Node>) -> bool | checker.go:8175 | Checker
is_template_literal_contextual_type | pub(crate) fn is_template_literal_contextual_type(&mut self, t: P<Type>) -> bool | checker.go:8180 | Checker
is_thenable_type | pub(crate) fn is_thenable_type(&mut self, t: P<Type>) -> bool | checker.go:31938 | Checker
is_this_initialized_declaration | pub(crate) fn is_this_initialized_declaration(node: Option<P<Node>>) -> bool | utilities.go:1075 | -
is_this_initialized_object_binding_expression | pub(crate) fn is_this_initialized_object_binding_expression(node: Option<P<Node>>) -> bool | utilities.go:1069 | -
is_this_property | pub(crate) fn is_this_property(node: P<Node>) -> bool | utilities.go:966 | -
is_this_property_access_in_constructor | pub(crate) fn is_this_property_access_in_constructor(&mut self, node: P<Node>, prop: P<Symbol>) -> bool | checker.go:27798 | Checker
is_this_property_assignment_declaration_redundant | pub fn is_this_property_assignment_declaration_redundant(&self, c: &mut Checker, node: Option<P<Node>>) -> bool | emitresolver.go:1292 | EmitResolver
is_this_type | pub fn is_this_type(&self) -> bool | rust:types.rs:2766 | TypeParameter
is_this_type_parameter | pub(crate) fn is_this_type_parameter(t: P<Type>) -> bool | utilities.go:1056 | -
is_thisless | pub(crate) fn is_thisless(symbol: P<Symbol>) -> bool | checker.go:21139 | -
is_thisless_function_like_declaration | pub(crate) fn is_thisless_function_like_declaration(node: P<Node>) -> bool | checker.go:21185 | -
is_thisless_interface | pub(crate) fn is_thisless_interface(&mut self, symbol: P<Symbol>) -> bool | checker.go:17680 | Checker
is_thisless_type | pub(crate) fn is_thisless_type(node: P<Node>) -> bool | checker.go:21169 | -
is_thisless_type_parameter | pub(crate) fn is_thisless_type_parameter(node: P<Node>) -> bool | checker.go:21193 | -
is_thisless_variable_like_declaration | pub(crate) fn is_thisless_variable_like_declaration(node: P<Node>) -> bool | checker.go:21158 | -
is_top_level_in_external_module_augmentation | pub(crate) fn is_top_level_in_external_module_augmentation(node: Option<P<Node>>) -> bool | utilities.go:245 | -
is_top_level_value_import_equals_with_entity_name | pub fn is_top_level_value_import_equals_with_entity_name(&self, c: &mut Checker, node: P<Node>) -> bool | emitresolver.go:789 | EmitResolver
is_top_signature | pub(crate) fn is_top_signature(&mut self, s: P<Signature>) -> bool | relater.go:1708 | Checker
is_trivially_serializable_computed_name | pub(crate) fn is_trivially_serializable_computed_name(&self, c: &mut Checker, e: Option<P<Node>>) -> bool | nodebuilderimpl.go:2150 | NodeBuilderImpl
is_truthy | pub fn is_truthy(v: LiteralValue) -> bool | rust:evaluator.rs:152 | -
is_tuple_like_type | pub(crate) fn is_tuple_like_type(&mut self, t: P<Type>) -> bool | checker.go:24005 | Checker
is_tuple_type | pub fn is_tuple_type(t: P<Type>) -> bool | checker.go:23950 | -
is_tuple_type | pub fn is_tuple_type(&self) -> bool | rust:types.rs:1768 | Type
is_tuple_type_exported | pub fn is_tuple_type_exported(t: P<Type>) -> bool | exports.go:219 | -
is_tuple_type_structure_matching | pub(crate) fn is_tuple_type_structure_matching(t1: P<Type>, t2: P<Type>) -> bool | inference.go:1202 | Checker
is_tuple_type_target | pub fn is_tuple_type_target(t: P<Type>) -> bool | exports.go:223 | -
is_type_alias | pub(crate) fn is_type_alias(node: P<Node>) -> bool | utilities.go:260 | -
is_type_any | pub fn is_type_any(t: Option<P<Type>>) -> bool | utilities.go:286 | -
is_type_assertion | pub(crate) fn is_type_assertion(node: P<Node>) -> bool | utilities.go:346 | -
is_type_assignable_to | pub fn is_type_assignable_to(&mut self, source: P<Type>, target: P<Type>) -> bool | relater.go:149 | Checker
is_type_assignable_to_exported | pub fn is_type_assignable_to_exported(&mut self, source: P<Type>, target: P<Type>) -> bool | exports.go:366 | Checker
is_type_assignable_to_kind | pub(crate) fn is_type_assignable_to_kind(&mut self, source: P<Type>, kind: TypeFlags) -> bool | checker.go:28111 | Checker
is_type_assignable_to_kind_ex | pub(crate) fn is_type_assignable_to_kind_ex(&mut self, source: P<Type>, kind: TypeFlags, strict: bool) -> bool | checker.go:28115 | Checker
is_type_closely_matched_by | pub(crate) fn is_type_closely_matched_by(s: P<Type>, t: P<Type>) -> bool | inference.go:1223 | Checker
is_type_comparable_to | pub(crate) fn is_type_comparable_to(&mut self, source: P<Type>, target: P<Type>) -> bool | relater.go:161 | Checker
is_type_derived_from | pub(crate) fn is_type_derived_from(&mut self, source: P<Type>, target: P<Type>) -> bool | relater.go:4995 | Checker
is_type_equality_comparable_to | pub(crate) fn is_type_equality_comparable_to(&mut self, source: P<Type>, target: P<Type>) -> bool | checker.go:13069 | Checker
is_type_identical_to | pub fn is_type_identical_to(&mut self, source: P<Type>, target: P<Type>) -> bool | relater.go:117 | Checker
is_type_invalid_due_to_union_discriminant | pub fn is_type_invalid_due_to_union_discriminant(&mut self, contextual_type: P<Type>, obj: P<Node>) -> bool | services.go:816 | Checker
is_type_matched_by_template_literal_or_string_mapping | pub(crate) fn is_type_matched_by_template_literal_or_string_mapping(&mut self, t: P<Type>, template: P<Type>) -> bool | checker.go:26344 | Checker
is_type_matched_by_template_literal_type | pub(crate) fn is_type_matched_by_template_literal_type(&mut self, source: P<Type>, target: &'static TemplateLiteralType, compare_types: TypeComparer) -> bool | relater.go:2365 | Checker
is_type_on_stack | pub(crate) fn is_type_on_stack(&self, _c: &mut Checker, t: P<Type>) -> bool | nodebuilderimpl.go:197 | NodeBuilderImpl
is_type_or_base_identical_to | pub(crate) fn is_type_or_base_identical_to(&mut self, s: P<Type>, t: P<Type>) -> bool | inference.go:1214 | Checker
is_type_parameter | pub fn is_type_parameter(&self) -> bool | rust:types.rs:1757 | Type
is_type_parameter_at_top_level | pub(crate) fn is_type_parameter_at_top_level(&mut self, t: P<Type>, tp: P<Type>, depth: u32) -> bool | inference.go:1493 | Checker
is_type_parameter_at_top_level_in_return_type | pub(crate) fn is_type_parameter_at_top_level_in_return_type(&mut self, signature: P<Signature>, type_parameter: P<Type>) -> bool | inference.go:1501 | Checker
is_type_parameter_possibly_referenced | pub(crate) fn is_type_parameter_possibly_referenced(&mut self, tp: P<Type>, node: P<Node>) -> bool | checker.go:22828 | Checker
is_type_presence_possible | pub(crate) fn is_type_presence_possible(&mut self, t: P<Type>, prop_name: &str, assume_true: bool) -> bool | flow.go:1024 | Checker
is_type_reference_identifier | pub(crate) fn is_type_reference_identifier(node: P<Node>) -> bool | utilities.go:161 | -
is_type_reference_with_generic_arguments | pub(crate) fn is_type_reference_with_generic_arguments(c: &mut Checker, t: P<Type>) -> bool | checker.go:17980 | -
is_type_related_to | pub(crate) fn is_type_related_to(&mut self, source: P<Type>, target: P<Type>, relation: P<Relation>) -> bool | relater.go:169 | Checker
is_type_strict_subtype_of | pub(crate) fn is_type_strict_subtype_of(&mut self, source: P<Type>, target: P<Type>) -> bool | relater.go:157 | Checker
is_type_subset_of | pub(crate) fn is_type_subset_of(&mut self, source: P<Type>, target: P<Type>) -> bool | relater.go:2863 | Checker
is_type_subset_of_union | pub(crate) fn is_type_subset_of_union(&mut self, source: P<Type>, target: P<Type>) -> bool | relater.go:2867 | Checker
is_type_subtype_of | pub(crate) fn is_type_subtype_of(&mut self, source: P<Type>, target: P<Type>) -> bool | relater.go:153 | Checker
is_type_symbol_accessible | pub fn is_type_symbol_accessible(&mut self, type_symbol: P<Symbol>, enclosing_declaration: Option<P<Node>>) -> bool | symbolaccessibility.go:11 | Checker
is_type_usable_as_index_signature_declaration | pub(crate) fn is_type_usable_as_index_signature_declaration(&mut self, t: P<Type>) -> bool | checker.go:20327 | Checker
is_type_usable_as_property_name | pub fn is_type_usable_as_property_name(t: P<Type>) -> bool | utilities.go:922 | -
is_type_usable_as_property_name_exported | pub fn is_type_usable_as_property_name_exported(t: P<Type>) -> bool | exports.go:91 | -
is_umd_export_symbol | pub(crate) fn is_umd_export_symbol(symbol: Option<P<Symbol>>) -> bool | symbolaccessibility.go:612 | -
is_unary_tuple_type_node | pub(crate) fn is_unary_tuple_type_node(node: P<Node>) -> bool | checker.go:25469 | -
is_uncalled_function_reference | pub(crate) fn is_uncalled_function_reference(&mut self, node: P<Node>, symbol: P<Symbol>) -> bool | checker.go:11895 | Checker
is_unchecked_js_suggestion | pub(crate) fn is_unchecked_js_suggestion(&self, node: Option<P<Node>>, suggestion: Option<P<Symbol>>, exclude_classes: bool) -> bool | utilities.go:1777 | Checker
is_undefined_symbol | pub fn is_undefined_symbol(&self, symbol: P<Symbol>) -> bool | services.go:236 | Checker
is_uniform_union_type | pub(crate) fn is_uniform_union_type(&mut self, t: P<Type>) -> bool | checker.go:28290 | Checker
is_union | pub fn is_union(&self) -> bool | rust:types.rs:1707 | Type
is_union_with_null | pub(crate) fn is_union_with_null(t: P<Type>) -> bool | checker.go:26699 | -
is_union_with_undefined | pub(crate) fn is_union_with_undefined(t: P<Type>) -> bool | checker.go:26695 | -
is_unit_like_type | pub(crate) fn is_unit_like_type(&mut self, t: P<Type>) -> bool | checker.go:25884 | Checker
is_unit_type | pub(crate) fn is_unit_type(t: P<Type>) -> bool | checker.go:25880 | -
is_unknown_like_union_type | pub(crate) fn is_unknown_like_union_type(&mut self, t: P<Type>) -> bool | checker.go:28273 | Checker
is_unknown_symbol | pub fn is_unknown_symbol(&self, symbol: P<Symbol>) -> bool | services.go:232 | Checker
is_unreadable_check_leaf | fn is_unreadable_check_leaf(&self, file: P<SourceFile>) -> bool | rust:printer.rs:888 | Checker
is_unreferenced_type_parameter | pub(crate) fn is_unreferenced_type_parameter(&mut self, type_parameter: P<Node>) -> bool | checker.go:7482 | Checker
is_unreferenced_variable_declaration | pub(crate) fn is_unreferenced_variable_declaration(&mut self, node: P<Node>) -> bool | checker.go:7393 | Checker
is_untyped_function_call | pub(crate) fn is_untyped_function_call(&mut self, func_type: P<Type>, apparent_func_type: P<Type>, num_call_signatures: usize, num_construct_signatures: usize) -> bool | checker.go:10125 | Checker
is_unwrapped_return_type_undefined_void_or_any | pub(crate) fn is_unwrapped_return_type_undefined_void_or_any(&mut self, fn_: P<Node>, return_type: P<Type>) -> bool | checker.go:3808 | Checker
is_used_in_function_or_instance_property | pub(crate) fn is_used_in_function_or_instance_property(&mut self, usage: P<Node>, declaration: P<Node>, decl_container: P<Node>) -> bool | checker.go:2052 | Checker
is_used_in_function_or_instance_property_callback | fn is_used_in_function_or_instance_property_callback(&mut self, current: P<Node>, usage: P<Node>, declaration: P<Node>, decl_container: P<Node>) -> ast::FindAncestorResult | rust:checker_01.rs:1290 | Checker
is_valid_base_type | pub(crate) fn is_valid_base_type(&mut self, t: P<Type>) -> bool | checker.go:19878 | Checker
is_valid_big_int_string | pub(crate) fn is_valid_big_int_string(s: &str, round_trip_only: bool) -> bool | utilities.go:978 | -
is_valid_const_assertion_argument | pub(crate) fn is_valid_const_assertion_argument(&mut self, node: P<Node>) -> bool | checker.go:13858 | Checker
is_valid_declaration_for_tuple_label | pub(crate) fn is_valid_declaration_for_tuple_label(d: P<Node>) -> bool | relater.go:1887 | Checker
is_valid_es_symbol_declaration | pub(crate) fn is_valid_es_symbol_declaration(node: P<Node>) -> bool | utilities.go:1004 | -
is_valid_index_key_type | pub(crate) fn is_valid_index_key_type(&mut self, t: P<Type>) -> bool | checker.go:20128 | Checker
is_valid_number_string | pub(crate) fn is_valid_number_string(s: &str, round_trip_only: bool) -> bool | utilities.go:970 | -
is_valid_override_of | pub(crate) fn is_valid_override_of(&mut self, source_prop: P<Symbol>, target_prop: P<Symbol>) -> bool | checker.go:12131 | Checker
is_valid_property_access | pub(crate) fn is_valid_property_access(&mut self, node: P<Node>, property_name: &str) -> bool | services.go:169 | Checker
is_valid_property_access_exported | pub fn is_valid_property_access_exported(&mut self, node: P<Node>, property_name: &str) -> bool | services.go:165 | Checker
is_valid_property_access_for_completions | pub(crate) fn is_valid_property_access_for_completions(&mut self, node: P<Node>, t: P<Type>, property: P<Symbol>) -> bool | checker.go:11828 | Checker
is_valid_property_access_for_completions_exported | pub fn is_valid_property_access_for_completions_exported(&mut self, node: P<Node>, t: P<Type>, property: P<Symbol>) -> bool | services.go:199 | Checker
is_valid_property_access_with_type | pub(crate) fn is_valid_property_access_with_type(&mut self, node: P<Node>, is_super: bool, property_name: &str, t: P<Type>) -> bool | services.go:181 | Checker
is_valid_spread_type | pub(crate) fn is_valid_spread_type(&mut self, t: P<Type>) -> bool | checker.go:13722 | Checker
is_valid_type_for_template_literal_placeholder | pub(crate) fn is_valid_type_for_template_literal_placeholder(&mut self, source: P<Type>, target: P<Type>, compare_types: TypeComparer) -> bool | relater.go:2509 | Checker
is_value_alias_declaration | pub fn is_value_alias_declaration(&self, c: &mut Checker, node: P<Node>) -> bool | emitresolver.go:723 | EmitResolver
is_value_alias_declaration_worker | pub(crate) fn is_value_alias_declaration_worker(&self, c: &mut Checker, node: P<Node>) -> bool | emitresolver.go:735 | EmitResolver
is_value_symbol_accessible | pub fn is_value_symbol_accessible(&mut self, symbol: Option<P<Symbol>>, enclosing_declaration: Option<P<Node>>) -> bool | symbolaccessibility.go:16 | Checker
is_var_const_like | pub(crate) fn is_var_const_like(&mut self, node: P<Node>) -> bool | checker.go:19042 | Checker
is_variable_declaration_in_variable_statement | pub(crate) fn is_variable_declaration_in_variable_statement(node: P<Node>) -> bool | utilities.go:1014 | -
is_variadic_tuple_element | pub(crate) fn is_variadic_tuple_element(node: P<Node>) -> bool | checker.go:24614 | Checker
is_weak_type | pub(crate) fn is_weak_type(&mut self, t: P<Type>) -> bool | relater.go:679 | Checker
is_yield_iterator_result | pub(crate) fn is_yield_iterator_result(&mut self, t: P<Type>) -> bool | checker.go:6852 | Checker
is_zero | pub fn is_zero(self) -> bool | checker.go:17703 | CacheHashKey
is_zero_big_int | pub(crate) fn is_zero_big_int(t: P<Type>) -> bool | checker.go:31625 | -
isolated_signature_type | pub fn isolated_signature_type(&self) -> Option<P<Type>> | rust:types.rs:3065 | Signature
issue_member_specific_error | pub(crate) fn issue_member_specific_error(&mut self, node: P<Node>, type_with_this: P<Type>, base_with_this: P<Type>, broad_diag: &'static Message) | checker.go:4546 | Checker
key_property_name | pub fn key_property_name(&self) -> &'static str | rust:types.rs:2671 | UnionType
key_type | pub fn key_type(&self) -> P<Type> | rust:types.rs:3155 | IndexInfo
keyed_at | fn keyed_at<V>(chunks: &[P<PSlot<V>>], index: u32) -> P<V> | rust:links.rs:209 | -
kind | pub fn kind(&self) -> TypeMapperKind | rust:mapper.rs:311 | TypeMapper
kind | pub fn kind(&self) -> TypePredicateKind | rust:types.rs:3128 | TypePredicate
known_property_or_index_type | fn known_property_or_index_type(&mut self, t: P<Type>, key: HashedName<'_>) -> Option<Option<P<Type>>> | rust:relater_1.rs:1981 | Checker
label | fn label(self) -> String | rust:workcensus.rs:447 | CKey
labeled_declaration | pub fn labeled_declaration(self) -> Option<P<Node>> | rust:types.rs:2385 | TupleElementInfo
late_bind_index_signature | pub(crate) fn late_bind_index_signature(&mut self, parent: P<Symbol>, early_symbols: Option<P<SymbolTable>>, late_symbols: P<SymbolTable>, decl: P<Node>) | checker.go:16391 | Checker
late_bind_member | pub(crate) fn late_bind_member(&mut self, parent: P<Symbol>, early_symbols: Option<P<SymbolTable>>, late_symbols: P<SymbolTable>, decl: P<Node>) -> Option<P<Symbol>> | checker.go:16328 | Checker
lazy_unaffected_members | fn lazy_unaffected_members(&mut self, source: P<Type>, declared_members: P<SymbolTable>, mapper: P<TypeMapper>) -> &'static [&'static str] | rust:checker_09.rs:2985 | Checker
lazy_unaffected_shadow | fn lazy_unaffected_shadow() -> bool | rust:checker_09.rs:2876 | -
len | pub fn len(&self) -> usize | rust:types.rs:126 | GoMap
len | pub fn len(&self) -> usize | rust:packedmap.rs:168 | GoPackedMap
len | pub(crate) fn len(&self, _c: &mut Checker) -> usize | checker.go:31208 | ObjectLiteralDiscriminator
len | pub fn len(&self) -> usize | rust:packedmap.rs:98 | PackedMap
len | pub fn len(&self) -> usize | rust:packedmap.rs:227 | StringLiteralTypes
len | pub(crate) fn len(&self, c: &Checker) -> usize | relater.go:1036 | TypeDiscriminator
lend | pub fn lend<R>(&self, c: &mut Checker, f: impl FnOnce() -> R) -> R | rust:nodebuilder_types.rs:223 | CheckerSlot
literal_bool_value | fn literal_bool_value(t: P<Type>) -> bool | rust:utilities.rs:947 | -
literal_number_value | fn literal_number_value(t: P<Type>) -> jsnum::Number | rust:utilities.rs:940 | -
literal_string_value | fn literal_string_value(t: P<Type>) -> &'static str | rust:utilities.rs:933 | -
literal_types_with_same_base_type | pub(crate) fn literal_types_with_same_base_type(&mut self, types: &[P<Type>]) -> bool | inference.go:1602 | Checker
literal_value_to_string | fn literal_value_to_string(value: Option<LiteralValue>) -> String | rust:checker_13.rs:13 | -
local_type_parameters | pub fn local_type_parameters(&self) -> &'static [P<Type>] | rust:types.rs:2333 | InterfaceType
location | fn location(node: Option<P<Node>>) -> String | rust:uniontrace.rs:116 | -
lookup | pub(crate) fn lookup(&self, flow: P<FlowNode>, key: u128) -> Option<MemoHit> | rust:flowmemo.rs:319 | FlowMemo
lookup | pub(crate) fn lookup(&self, key: RelationKey) -> RelationComparisonResult | relater.go:102 | Relation
lookup_export | fn lookup_export(symbol: P<Symbol>, name: &str) -> Option<P<Symbol>> | rust:checker_07.rs:1970 | -
lookup_expression_chain_type_argument_nodes | pub(crate) fn lookup_expression_chain_type_argument_nodes(&self, c: &mut Checker, chain: &[P<Symbol>], index: usize) -> Option<P<NodeList>> | nodebuilderimpl.go:3696 | NodeBuilderImpl
lookup_instantiated_type_argument_nodes | pub(crate) fn lookup_instantiated_type_argument_nodes(&self, c: &mut Checker, chain: &[P<Symbol>], index: usize) -> Option<P<NodeList>> | nodebuilderimpl.go:3669 | NodeBuilderImpl
lookup_or_issue_error | pub(crate) fn lookup_or_issue_error(&mut self, location: P<Node>, message: &'static Message, args: &[&dyn Display]) -> P<Diagnostic> | checker.go:14505 | Checker
lookup_symbol_chain | pub(crate) fn lookup_symbol_chain(&self, c: &mut Checker, symbol: P<Symbol>, meaning: SymbolFlags, yield_module_symbol: bool) -> Vec<P<Symbol>> | nodebuilderimpl.go:1061 | NodeBuilderImpl
lookup_symbol_chain_worker | pub(crate) fn lookup_symbol_chain_worker(&self, c: &mut Checker, symbol: P<Symbol>, meaning: SymbolFlags, yield_module_symbol: bool) -> Vec<P<Symbol>> | nodebuilderimpl.go:1066 | NodeBuilderImpl
lookup_symbol_for_private_identifier_declaration | pub(crate) fn lookup_symbol_for_private_identifier_declaration(prop_name: &str, location: P<Node>) -> Option<P<Symbol>> | checker.go:11675 | Checker
lookup_type_parameter_nodes | pub(crate) fn lookup_type_parameter_nodes(&self, c: &mut Checker, chain: &[P<Symbol>], index: usize) -> Option<P<NodeList>> | nodebuilderimpl.go:1036 | NodeBuilderImpl
make | pub fn make(&self) | rust:types.rs:76 | GoMap
make | pub fn make(&self) | rust:packedmap.rs:133 | GoPackedMap
make | pub fn make(&self) | rust:types.rs:2274 | ReferenceInstantiations
make_key | fn make_key(types: &[P<Type>], reduction: UnionReduction, alias: AliasArg<'_>, shift: u32) -> Option<([PKey; MAX_WORDS], u16, usize)> | rust:unioncache.rs:184 | -
make_long_key | fn make_long_key(words: &mut Vec<PKey>, types: &[P<Type>], reduction: UnionReduction, alias: AliasArg<'_>) -> Option<(u16, u64)> | rust:unioncache.rs:218 | -
map | pub fn map(&self, c: &mut Checker, t: P<Type>) -> P<Type> | rust:mapper.rs:255 | TypeMapper
map_to_type_nodes | pub(crate) fn map_to_type_nodes(&self, c: &mut Checker, list: &[P<Type>], is_bare_list: bool) -> Option<P<NodeList>> | nodebuilderimpl.go:349 | NodeBuilderImpl
map_type | pub(crate) fn map_type(&mut self, t: P<Type>, f: impl FnMut(&mut Checker, P<Type>) -> Option<P<Type>>) -> Option<P<Type>> | checker.go:26031 | Checker
map_type_ex | pub(crate) fn map_type_ex(&mut self, t: P<Type>, f: impl FnMut(&mut Checker, P<Type>) -> Option<P<Type>>, no_reductions: bool) -> Option<P<Type>> | checker.go:26035 | Checker
map_type_ex_worker | fn map_type_ex_worker(&mut self, t: P<Type>, f: &mut dyn FnMut(&mut Checker, P<Type>) -> Option<P<Type>>, no_reductions: bool) -> Option<P<Type>> | rust:checker_12.rs:2617 | Checker
map_type_with_alias | pub(crate) fn map_type_with_alias(&mut self, t: P<Type>, f: impl FnMut(&mut Checker, P<Type>) -> P<Type>, alias: Option<P<TypeAlias>>) -> P<Type> | checker.go:26024 | Checker
map_type_with_composite_mapper | pub(crate) fn map_type_with_composite_mapper(&mut self, t: P<Type>, m1: Option<P<TypeMapper>>, m2: P<TypeMapper>) -> P<Type> | rust:mapper.rs:442 | Checker
map_types_by_key_property | pub(crate) fn map_types_by_key_property(&mut self, types: &[P<Type>], key_property_name: &str) -> FxHashMap<P<Type>, P<Type>> | relater.go:1169 | Checker
mapped_type_add_member_for_key_type | fn mapped_type_add_member_for_key_type(c: &mut Checker, st: &mut MappedTypeMembersState, key_type: P<Type>) | rust:checker_10.rs:2308 | -
mapped_type_add_member_for_key_type_worker | fn mapped_type_add_member_for_key_type_worker(c: &mut Checker, st: &mut MappedTypeMembersState, key_type: P<Type>, prop_name_type: P<Type>) | rust:checker_10.rs:2271 | -
mapped_type_related_to | pub(crate) fn mapped_type_related_to(&self, c: &mut Checker, source: P<Type>, target: P<Type>, report_errors: bool) -> Ternary | relater.go:4004 | Relater
mapper | pub fn mapper(&self) -> Option<P<TypeMapper>> | rust:checker.rs:390 | InferenceContext
mapper | pub fn mapper(&self) -> Option<P<TypeMapper>> | rust:types.rs:1638 | Type
mapper | pub fn mapper(&self) -> Option<P<TypeMapper>> | rust:types.rs:461 | ValueSymbolLinks
maps_this_only | pub fn maps_this_only(&self) -> bool | rust:mapper.rs:320 | TypeMapper
mark_alias_referenced | pub(crate) fn mark_alias_referenced(&mut self, symbol: P<Symbol>, location: P<Node>) | checker.go:29272 | Checker
mark_alias_symbol_as_referenced | pub(crate) fn mark_alias_symbol_as_referenced(&mut self, symbol: P<Symbol>) | checker.go:29294 | Checker
mark_as_synthetic | pub(crate) fn mark_as_synthetic(node: P<Node>) -> bool | jsx.go:1443 | -
mark_decorator_alias_referenced | pub(crate) fn mark_decorator_alias_referenced(&mut self, node: P<Node>) | checker.go:29156 | Checker
mark_decorator_medata_data_type_node_as_referenced | pub(crate) fn mark_decorator_medata_data_type_node_as_referenced(&mut self, node: Option<P<Node>>) | checker.go:29212 | Checker
mark_entity_name_or_entity_expression_as_reference | pub(crate) fn mark_entity_name_or_entity_expression_as_reference(&mut self, type_name: Option<P<Node>>, for_decorator_metadata: bool) | checker.go:29327 | Checker
mark_error | pub(crate) fn mark_error(&self, f: Option<Box<dyn FnOnce()>>) | nodecopy.go:109 | recoveryBoundary
mark_export_as_referenced | pub(crate) fn mark_export_as_referenced(&mut self, node: P<Node>) | checker.go:29315 | Checker
mark_export_assignment_alias_referenced | pub(crate) fn mark_export_assignment_alias_referenced(&mut self, location: P<Node>) | checker.go:28962 | Checker
mark_export_specifier_alias_referenced | pub(crate) fn mark_export_specifier_alias_referenced(&mut self, location: P<Node>) | checker.go:29024 | Checker
mark_identifier_alias_referenced | pub(crate) fn mark_identifier_alias_referenced(&mut self, location: P<Node>) | checker.go:28867 | Checker
mark_import_equals_alias_referenced | pub(crate) fn mark_import_equals_alias_referenced(&mut self, location: P<Node>) | checker.go:29018 | Checker
mark_jsx_alias_referenced | pub(crate) fn mark_jsx_alias_referenced(&mut self, node: P<Node>) | checker.go:28972 | Checker
mark_linked_aliases | pub(crate) fn mark_linked_aliases(&self, c: &mut Checker, node: P<Node>) | emitresolver.go:278 | EmitResolver
mark_linked_references | pub(crate) fn mark_linked_references(&mut self, location: P<Node>, hint: ReferenceHint, prop_symbol: Option<P<Symbol>>, parent_type: Option<P<Type>>) | checker.go:28659 | Checker
mark_linked_references_recursively | pub fn mark_linked_references_recursively(&self, c: &mut Checker, file: Option<P<SourceFile>>) | emitresolver.go:808 | EmitResolver
mark_linked_references_recursively_visit | fn mark_linked_references_recursively_visit(c: &mut Checker, n: P<Node>) -> bool | rust:emitresolver.rs:888 | -
mark_node_assignments | pub(crate) fn mark_node_assignments(&mut self, node: P<Node>) -> bool | rust:checker.rs:2456 | Checker
mark_node_assignments_worker | pub(crate) fn mark_node_assignments_worker(&mut self, node: P<Node>) -> bool | flow.go:2700 | Checker
mark_property_alias_referenced | pub(crate) fn mark_property_alias_referenced(&mut self, location: P<Node>, prop_symbol: Option<P<Symbol>>, parent_type: Option<P<Type>>) | checker.go:28877 | Checker
mark_property_as_referenced | pub(crate) fn mark_property_as_referenced(&mut self, prop: P<Symbol>, node_for_check_write_only: Option<P<Node>>, is_self_type_access: bool) | checker.go:28176 | Checker
mark_symbol_name_literal | pub(crate) fn mark_symbol_name_literal(&self, node: P<Node>) -> P<Node> | rust:nodebuilderimpl_2.rs:1983 | NodeBuilderImpl
mark_symbol_of_alias_declaration_if_type_only | pub(crate) fn mark_symbol_of_alias_declaration_if_type_only(&mut self, alias_declaration: Option<P<Node>>, export_star_declaration: Option<P<Node>>) -> bool | checker.go:15326 | Checker
matches | pub(crate) fn matches(&self, c: &mut Checker, index: usize, t: P<Type>) -> bool | checker.go:31219 | ObjectLiteralDiscriminator
matches | pub(crate) fn matches(&mut self, c: &mut Checker, index: usize, t: P<Type>) -> bool | relater.go:1044 | TypeDiscriminator
may_be_augment_member | pub(crate) fn may_be_augment_member(&mut self, key: HashedName<'_>) -> bool | rust:checker_09.rs:2429 | Checker
may_be_const_type_variable | fn may_be_const_type_variable(t: P<Type>) -> bool | rust:checker_07.rs:1123 | Checker
may_have_lazy_members | pub(crate) fn may_have_lazy_members(t: P<Type>) -> bool | rust:checker_09.rs:2881 | -
may_resolve_type_alias | pub(crate) fn may_resolve_type_alias(&mut self, node: P<Node>) -> bool | checker.go:23732 | Checker
may_return_never | pub(crate) fn may_return_never(fn_: P<Node>) -> bool | checker.go:20653 | -
maybe_add_missing_await_info | pub(crate) fn maybe_add_missing_await_info(&mut self, error_node: Option<P<Node>>, source: P<Type>, target: P<Type>, relation: P<Relation>, report_errors: bool, diagnostic_output: Option<&mut Vec<P<Diagnostic>>>) | checker.go:9523 | Checker
maybe_constituent_of_kind | fn maybe_constituent_of_kind(types: &[P<Type>], kind: TypeFlags) -> bool | rust:checker_13.rs:1353 | -
maybe_mapped_type | pub(crate) fn maybe_mapped_type(&mut self, node: P<Node>, symbol: P<Symbol>) -> bool | checker.go:1749 | Checker
maybe_stack_has | fn maybe_stack_has(&self, key: &RelationKey) -> bool | rust:relater_2.rs:943 | Relater
maybe_stack_push | fn maybe_stack_push(&self, key: RelationKey) | rust:relater_2.rs:951 | Relater
maybe_type_of_kind | pub(crate) fn maybe_type_of_kind(&mut self, t: P<Type>, kind: TypeFlags) -> bool | checker.go:28076 | Checker
maybe_type_of_kind_considering_base_constraint | pub(crate) fn maybe_type_of_kind_considering_base_constraint(&mut self, t: P<Type>, kind: TypeFlags) -> bool | checker.go:28090 | Checker
members | pub fn members(&self) -> Option<P<SymbolTable>> | rust:types.rs:2125 | StructuredType
members_related_to_index_info | pub(crate) fn members_related_to_index_info(&self, c: &mut Checker, source: P<Type>, target_info: P<IndexInfo>, report_errors: bool, intersection_state: IntersectionState) -> Ternary | relater.go:4666 | Relater
members_resolved_like_go | pub fn members_resolved_like_go(&self, t: P<Type>) -> bool | rust:checker_09.rs:2899 | Checker
memo_bits | pub(crate) fn memo_bits(self) -> u32 | rust:checker.rs:670 | InferencePriority
merge_ascending_runs | fn merge_ascending_runs(c: &mut Checker, types: &mut Vec<P<Type>>, run_starts: &[usize]) | rust:checker_13.rs:1259 | -
merge_global_symbol | pub(crate) fn merge_global_symbol(&mut self, symbol: P<Symbol>) | checker.go:1397 | Checker
merge_inferences | pub(crate) fn merge_inferences(target: &mut [P<InferenceInfo>], source: &[P<InferenceInfo>]) | inference.go:1679 | Checker
merge_module_augmentation | pub(crate) fn merge_module_augmentation(&mut self, module_name: P<Node>) | checker.go:1436 | Checker
merge_pattern_ambient_modules | pub(crate) fn merge_pattern_ambient_modules(&mut self) | checker.go:1409 | Checker
merge_sorted_types | fn merge_sorted_types(c: &mut Checker, left: &[P<Type>], right: &[P<Type>], dedup: bool, out: &mut impl FnMut(&mut Checker, P<Type>)) | rust:checker_13.rs:1302 | -
merge_symbol | pub(crate) fn merge_symbol(&mut self, target: P<Symbol>, source: P<Symbol>, unidirectional: bool) -> P<Symbol> | checker.go:14381 | Checker
merge_symbol_table | pub(crate) fn merge_symbol_table(&mut self, target: P<SymbolTable>, source: Option<P<SymbolTable>>, unidirectional: bool, merged_parent: Option<P<Symbol>>) | checker.go:14344 | Checker
merge_type_mappers | pub(crate) fn merge_type_mappers(m1: Option<P<TypeMapper>>, m2: P<TypeMapper>) -> P<TypeMapper> | rust:mapper.rs:489 | -
min_and_max | pub(crate) fn min_and_max<T: Copy>(slice: &[T], get_value: impl FnMut(T) -> usize) -> (usize, usize) | utilities.go:1316 | -
min_argument_count | pub fn min_argument_count(&self) -> usize | rust:types.rs:3093 | Signature
min_priority | fn min_priority(a: InferencePriority, b: InferencePriority) -> InferencePriority | rust:inference.rs:7 | -
min_steps | fn min_steps() -> u32 | rust:infermemo.rs:93 | -
mode | fn mode(&self) -> LinksMode | rust:types.rs:402 | ValueSymbolLinks
mode_from_env | fn mode_from_env() -> FlowMemoMode | rust:flowmemo.rs:51 | -
module_specifier_resolves_to_symbol | pub(crate) fn module_specifier_resolves_to_symbol(&self, c: &mut Checker, specifier: &str, import_attributes_type: P<Type>, symbol: P<Symbol>) -> bool | nodebuilderimpl.go:1347 | NodeBuilderImpl
module_specifier_result_for_symbol | pub(crate) fn module_specifier_result_for_symbol(&self, c: &mut Checker, result: moduleSpecifierResult, import_attributes_type: Option<P<Type>>, symbol: P<Symbol>) -> moduleSpecifierResult | nodebuilderimpl.go:1340 | NodeBuilderImpl
modules_exporting | fn modules_exporting(&mut self, symbol: P<Symbol>) -> Option<Vec<P<Symbol>>> | rust:printer.rs:824 | Checker
ms | fn ms(ns: u64) -> f64 | rust:workcensus.rs:619 | -
name | fn name(self) -> &'static str | rust:workcensus.rs:64 | Cat
name | pub(crate) fn name(&self, _c: &mut Checker, index: usize) -> &'static str | checker.go:31212 | ObjectLiteralDiscriminator
name | pub(crate) fn name(&self, c: &Checker, index: usize) -> &'static str | relater.go:1040 | TypeDiscriminator
name_type | pub fn name_type(&self) -> Option<P<Type>> | rust:types.rs:2458 | MappedType
name_type | pub fn name_type(&self) -> Option<P<Type>> | rust:types.rs:501 | ValueSymbolLinks
narrow | fn narrow(&self, id: u32) -> Option<&'static V> | rust:links.rs:579 | InlineIdStore
narrow_slot | fn narrow_slot(&self, id: u32) -> Option<u32> | rust:links.rs:428 | IdLinkStore
narrow_type | pub(crate) fn narrow_type(&mut self, f: P<FlowState>, t: P<Type>, expr: P<Node>, assume_true: bool) -> P<Type> | flow.go:377 | Checker
narrow_type_by_assertion | pub(crate) fn narrow_type_by_assertion(&mut self, f: P<FlowState>, t: P<Type>, expr: P<Node>) -> P<Type> | flow.go:338 | Checker
narrow_type_by_binary_expression | pub(crate) fn narrow_type_by_binary_expression(&mut self, f: P<FlowState>, t: P<Type>, expr: P<Node>, assume_true: bool) -> P<Type> | flow.go:469 | Checker
narrow_type_by_boolean_comparison | pub(crate) fn narrow_type_by_boolean_comparison(&mut self, f: P<FlowState>, t: P<Type>, expr: P<Node>, bool_value: P<Node>, operator: Kind, assume_true: bool) -> P<Type> | flow.go:806 | Checker
narrow_type_by_call_expression | pub(crate) fn narrow_type_by_call_expression(&mut self, f: P<FlowState>, t: P<Type>, call_expression: P<Node>, assume_true: bool) -> P<Type> | flow.go:444 | Checker
narrow_type_by_constructor | pub(crate) fn narrow_type_by_constructor(&mut self, t: P<Type>, operator: Kind, identifier: P<Node>, assume_true: bool) -> P<Type> | flow.go:760 | Checker
narrow_type_by_discriminant | pub(crate) fn narrow_type_by_discriminant(&mut self, t: P<Type>, access: P<Node>, narrow_type: impl FnMut(&mut Checker, P<Type>) -> P<Type>) -> P<Type> | flow.go:725 | Checker
narrow_type_by_discriminant_property | pub(crate) fn narrow_type_by_discriminant_property(&mut self, t: P<Type>, access: P<Node>, operator: Kind, value: P<Node>, assume_true: bool) -> P<Type> | flow.go:702 | Checker
narrow_type_by_equality | pub(crate) fn narrow_type_by_equality(&mut self, t: P<Type>, operator: Kind, value: P<Node>, assume_true: bool) -> P<Type> | flow.go:556 | Checker
narrow_type_by_in_keyword | pub(crate) fn narrow_type_by_in_keyword(&mut self, _f: P<FlowState>, t: P<Type>, name_type: P<Type>, assume_true: bool) -> P<Type> | flow.go:1001 | Checker
narrow_type_by_instanceof | pub(crate) fn narrow_type_by_instanceof(&mut self, f: P<FlowState>, t: P<Type>, expr: P<Node>, assume_true: bool) -> P<Type> | flow.go:811 | Checker
narrow_type_by_literal_expression | pub(crate) fn narrow_type_by_literal_expression(&mut self, t: P<Type>, literal: P<Node>, assume_true: bool) -> P<Type> | flow.go:646 | Checker
narrow_type_by_optional_chain_containment | pub(crate) fn narrow_type_by_optional_chain_containment(&mut self, _f: P<FlowState>, t: P<Type>, operator: Kind, value: P<Node>, assume_true: bool) -> P<Type> | flow.go:1032 | Checker
narrow_type_by_optionality | pub(crate) fn narrow_type_by_optionality(&mut self, f: P<FlowState>, t: P<Type>, expr: P<Node>, assume_present: bool) -> P<Type> | flow.go:415 | Checker
narrow_type_by_private_identifier_in_in_expression | pub(crate) fn narrow_type_by_private_identifier_in_in_expression(&mut self, f: P<FlowState>, t: P<Type>, expr: P<Node>, assume_true: bool) -> P<Type> | flow.go:982 | Checker
narrow_type_by_switch_on_discriminant | pub(crate) fn narrow_type_by_switch_on_discriminant(&mut self, t: P<Type>, data: P<Node>) -> P<Type> | flow.go:1091 | Checker
narrow_type_by_switch_on_discriminant_property | pub(crate) fn narrow_type_by_switch_on_discriminant_property(&mut self, t: P<Type>, access: P<Node>, data: P<Node>) -> P<Type> | flow.go:1231 | Checker
narrow_type_by_switch_on_true | pub(crate) fn narrow_type_by_switch_on_true(&mut self, f: P<FlowState>, t: P<Type>, data: P<Node>) -> P<Type> | flow.go:1187 | Checker
narrow_type_by_switch_on_type_of | pub(crate) fn narrow_type_by_switch_on_type_of(&mut self, t: P<Type>, data: P<Node>) -> P<Type> | flow.go:1157 | Checker
narrow_type_by_switch_optional_chain_containment | pub(crate) fn narrow_type_by_switch_optional_chain_containment(&mut self, t: P<Type>, data: P<Node>, clause_check: impl FnMut(&mut Checker, P<Type>) -> bool) -> P<Type> | flow.go:1223 | Checker
narrow_type_by_truthiness | pub(crate) fn narrow_type_by_truthiness(&mut self, f: P<FlowState>, t: P<Type>, expr: P<Node>, assume_true: bool) -> P<Type> | flow.go:428 | Checker
narrow_type_by_type_facts | pub(crate) fn narrow_type_by_type_facts(&mut self, t: P<Type>, implied_type: P<Type>, facts: TypeFacts) -> P<Type> | flow.go:685 | Checker
narrow_type_by_type_name | pub(crate) fn narrow_type_by_type_name(&mut self, t: P<Type>, type_name: &str) -> P<Type> | flow.go:657 | Checker
narrow_type_by_type_predicate | pub(crate) fn narrow_type_by_type_predicate(&mut self, f: P<FlowState>, t: P<Type>, predicate: P<TypePredicate>, call_expression: P<Node>, assume_true: bool) -> P<Type> | flow.go:316 | Checker
narrow_type_by_typeof | pub(crate) fn narrow_type_by_typeof(&mut self, f: P<FlowState>, t: P<Type>, type_of_expr: P<Node>, operator: Kind, literal: P<Node>, assume_true: bool) -> P<Type> | flow.go:614 | Checker
need_collision_check_for_identifier | pub(crate) fn need_collision_check_for_identifier(node: P<Node>, identifier: Option<P<Node>>, name: &str) -> bool | checker.go:10696 | Checker
needs_qualification | pub(crate) fn needs_qualification(&mut self, symbol: P<Symbol>, enclosing_declaration: Option<P<Node>>, meaning: SymbolFlags) -> bool | symbolaccessibility.go:688 | Checker
new | pub fn new() -> Box<Census> | rust:workcensus.rs:193 | Census
new | fn new(len: usize, pairs: Vec<(P<Symbol>, P<Symbol>)>) -> ExportsByTarget | rust:printer.rs:1677 | ExportsByTarget
new | pub fn new() -> FlowMemo | rust:flowmemo.rs:193 | FlowMemo
new | pub(crate) fn new() -> Self | rust:infermemo.rs:138 | InferMemo
new | pub(crate) fn new(inferences: &'static [P<InferenceInfo>], signature: Option<P<Signature>>, flags: InferenceFlags, compare_types: TypeComparer) -> InferenceContext | rust:checker.rs:345 | InferenceContext
new | pub fn new(m: Option<P<TypeMapper>>) -> MapperCell | rust:mapper.rs:407 | MapperCell
new | pub fn new(host: &'static dyn ModuleSpecifierGenerationHost) -> NodeBuilderContext | rust:nodebuilder_types.rs:123 | NodeBuilderContext
new | pub const fn new(f: ObjectFlags) -> Self | rust:types.rs:1220 | ObjectFlagsCell
new | pub fn new() -> Self | rust:packedmap.rs:60 | PackedMap
new | pub fn new(symbol: Option<P<Symbol>>, type_arguments: Vec<P<Type>>) -> PendingTypeAlias | rust:types.rs:1137 | PendingTypeAlias
new | pub(crate) fn new(t: P<Type>) -> RelaterStackEntry | rust:relater_types.rs:202 | RelaterStackEntry
new | pub(crate) fn new() -> Self | rust:unioncache.rs:148 | UnionFrontCache
new_anonymous_type | pub(crate) fn new_anonymous_type(&mut self, symbol: Option<P<Symbol>>, members: Option<P<SymbolTable>>, call_signatures: &[P<Signature>], construct_signatures: &[P<Signature>], index_infos: &[P<IndexInfo>]) -> P<Type> | checker.go:25560 | Checker
new_array_to_single_type_mapper | pub(crate) fn new_array_to_single_type_mapper(sources: &'static [P<Type>], target: P<Type>) -> P<TypeMapper> | rust:mapper.rs:528 | -
new_array_type_mapper | pub(crate) fn new_array_type_mapper(sources: &'static [P<Type>], targets: &'static [P<Type>]) -> P<TypeMapper> | rust:mapper.rs:519 | -
new_backreference_mapper | pub(crate) fn new_backreference_mapper(&self, context: P<InferenceContext>, index: usize) -> P<TypeMapper> | rust:mapper.rs:456 | Checker
new_call_signature | pub(crate) fn new_call_signature(&mut self, type_parameters: &[P<Type>], this_parameter: Option<P<Symbol>>, parameters: &[P<Symbol>], return_type: P<Type>) -> P<Signature> | checker.go:31008 | Checker
new_checker | pub fn new_checker(program: &'static dyn Program) -> Box<Checker> | checker.go:911 | -
new_class_accessor_decorator_context_type | pub(crate) fn new_class_accessor_decorator_context_type(&mut self, this_type: P<Type>, value_type: P<Type>) -> P<Type> | checker.go:30912 | Checker
new_class_accessor_decorator_result_type | pub(crate) fn new_class_accessor_decorator_result_type(&mut self, this_type: P<Type>, value_type: P<Type>) -> P<Type> | checker.go:30973 | Checker
new_class_accessor_decorator_target_type | pub(crate) fn new_class_accessor_decorator_target_type(&mut self, this_type: P<Type>, value_type: P<Type>) -> P<Type> | checker.go:30969 | Checker
new_class_decorator_context_type | pub(crate) fn new_class_decorator_context_type(&mut self, class_type: P<Type>) -> P<Type> | checker.go:30896 | Checker
new_class_field_decorator_context_type | pub(crate) fn new_class_field_decorator_context_type(&mut self, this_type: P<Type>, value_type: P<Type>) -> P<Type> | checker.go:30916 | Checker
new_class_field_decorator_initializer_mutator_type | pub(crate) fn new_class_field_decorator_initializer_mutator_type(&mut self, this_type: P<Type>, value_type: P<Type>) -> P<Type> | checker.go:30977 | Checker
new_class_getter_decorator_context_type | pub(crate) fn new_class_getter_decorator_context_type(&mut self, class_type: P<Type>, value_type: P<Type>) -> P<Type> | checker.go:30904 | Checker
new_class_member_decorator_context_type_for_node | pub(crate) fn new_class_member_decorator_context_type_for_node(&mut self, node: P<Node>, this_type: P<Type>, value_type: P<Type>) -> P<Type> | checker.go:30941 | Checker
new_class_method_decorator_context_type | pub(crate) fn new_class_method_decorator_context_type(&mut self, class_type: P<Type>, value_type: P<Type>) -> P<Type> | checker.go:30900 | Checker
new_class_setter_decorator_context_type | pub(crate) fn new_class_setter_decorator_context_type(&mut self, class_type: P<Type>, value_type: P<Type>) -> P<Type> | checker.go:30908 | Checker
new_composite_type_mapper | pub(crate) fn new_composite_type_mapper(m1: P<TypeMapper>, m2: P<TypeMapper>) -> P<TypeMapper> | rust:mapper.rs:555 | -
new_conditional_type | pub(crate) fn new_conditional_type(&mut self, root: P<ConditionalRoot>, mapper: Option<P<TypeMapper>>, combined_mapper: Option<P<TypeMapper>>) -> P<Type> | checker.go:25700 | Checker
new_deferred_type_mapper | pub(crate) fn new_deferred_type_mapper(sources: &'static [P<Type>], targets: Vec<Box<dyn Fn(&mut Checker) -> P<Type>>>) -> P<TypeMapper> | rust:mapper.rs:537 | -
new_diagnostic_chain_for_node | pub fn new_diagnostic_chain_for_node(chain: Option<P<Diagnostic>>, node: P<Node>, message: Option<&'static Message>, args: &[&dyn Display]) -> P<Diagnostic> | utilities.go:31 | -
new_diagnostic_for_node | pub fn new_diagnostic_for_node(node: Option<P<Node>>, message: Option<&'static Message>, args: &[&dyn Display]) -> P<Diagnostic> | utilities.go:21 | -
new_emit_resolver | pub(crate) fn new_emit_resolver(_checker: &mut Checker) -> P<EmitResolver> | emitresolver.go:45 | -
new_empty | pub fn new_empty() -> Self | rust:types.rs:69 | GoMap
new_es_decorator_call_signature | pub(crate) fn new_es_decorator_call_signature(&mut self, target_type: P<Type>, context_type: P<Type>, non_optional_return_type: P<Type>) -> P<Signature> | checker.go:30985 | Checker
new_flow_type | pub(crate) fn new_flow_type(&self, t: P<Type>, incomplete: bool) -> FlowType | flow.go:28 | Checker
new_function_type | pub(crate) fn new_function_type(&mut self, type_parameters: &[P<Type>], this_parameter: Option<P<Symbol>>, parameters: &[P<Symbol>], return_type: P<Type>) -> P<Type> | checker.go:30993 | Checker
new_function_type_mapper | pub(crate) fn new_function_type_mapper(f: fn(&mut Checker, P<Type>) -> P<Type>) -> P<TypeMapper> | rust:mapper.rs:543 | -
new_getter_function_type | pub(crate) fn new_getter_function_type(&mut self, t: P<Type>) -> P<Type> | checker.go:30998 | Checker
new_identifier | pub(crate) fn new_identifier(&self, _c: &mut Checker, text: &str, symbol: Option<P<Symbol>>) -> P<Node> | nodebuilderimpl.go:3643 | NodeBuilderImpl
new_index_info | pub(crate) fn new_index_info(key_type: P<Type>, value_type: P<Type>, is_readonly: bool, declaration: Option<P<Node>>, components: &[P<Node>]) -> P<IndexInfo> | checker.go:25733 | Checker
new_index_type | pub(crate) fn new_index_type(&mut self, target: P<Type>, index_flags: IndexFlags) -> P<Type> | checker.go:25678 | Checker
new_indexed_access_type | pub(crate) fn new_indexed_access_type(&mut self, object_type: P<Type>, index_type: P<Type>, access_flags: AccessFlags) -> P<Type> | checker.go:25670 | Checker
new_inference_context | pub(crate) fn new_inference_context(type_parameters: &[P<Type>], signature: Option<P<Signature>>, flags: InferenceFlags, compare_types: Option<TypeComparer>) -> P<InferenceContext> | inference.go:1251 | Checker
new_inference_context_worker | pub(crate) fn new_inference_context_worker(inferences: &[P<InferenceInfo>], signature: Option<P<Signature>>, flags: InferenceFlags, compare_types: TypeComparer) -> P<InferenceContext> | inference.go:1273 | Checker
new_inference_info | pub(crate) fn new_inference_info(type_parameter: P<Type>) -> P<InferenceInfo> | inference.go:1626 | -
new_inference_type_mapper | pub(crate) fn new_inference_type_mapper(n: P<InferenceContext>, fixing: bool) -> P<TypeMapper> | rust:mapper.rs:475 | -
new_instantiated_symbol | pub(crate) fn new_instantiated_symbol(&mut self, symbol: P<Symbol>, m: Option<P<TypeMapper>>) -> P<Symbol> | rust:checker_10.rs:1798 | Checker
new_intersection_type | pub(crate) fn new_intersection_type(&mut self, object_flags: ObjectFlags, types: &[P<Type>]) -> P<Type> | checker.go:25664 | Checker
new_intrinsic_type | pub(crate) fn new_intrinsic_type(&mut self, flags: TypeFlags, intrinsic_name: &str) -> P<Type> | checker.go:25487 | Checker
new_intrinsic_type_ex | pub(crate) fn new_intrinsic_type_ex(&mut self, flags: TypeFlags, intrinsic_name: &str, object_flags: ObjectFlags) -> P<Type> | checker.go:25491 | Checker
new_literal_type | pub(crate) fn new_literal_type(&mut self, flags: TypeFlags, value: Option<LiteralValue>, regular_type: Option<P<Type>>) -> P<Type> | checker.go:25513 | Checker
new_mapped_type_member | pub(crate) fn new_mapped_type_member(&mut self, t: P<Type>, modifiers_type: P<Type>, template_modifiers: MappedTypeModifiers, should_link_prop_declarations: bool, key_type: P<Type>, prop_name_type: P<Type>, prop_name: &str) -> P<Symbol> | rust:checker_10.rs:2048 | Checker
new_merged_type_mapper | pub(crate) fn new_merged_type_mapper(m1: P<TypeMapper>, m2: P<TypeMapper>) -> P<TypeMapper> | rust:mapper.rs:549 | -
new_node_builder | pub fn new_node_builder(ch: &Checker, e: P<EmitContext>) -> P<NodeBuilder> | nodebuilder.go:279 | -
new_node_builder_ex | pub fn new_node_builder_ex(ch: &Checker, e: P<EmitContext>, id_to_symbol: Option<P<RefCell<FxHashMap<P<Node>, P<Symbol>>>>>) -> P<NodeBuilder> | nodebuilder.go:283 | -
new_node_builder_impl | pub(crate) fn new_node_builder_impl(ch: &Checker, e: P<EmitContext>, id_to_symbol: Option<P<RefCell<FxHashMap<P<Node>, P<Symbol>>>>>) -> P<NodeBuilderImpl> | nodebuilderimpl.go:125 | -
new_object_type | pub(crate) fn new_object_type(&mut self, object_flags: ObjectFlags, symbol: Option<P<Symbol>>) -> P<Type> | checker.go:25533 | Checker
new_parameter | pub(crate) fn new_parameter(&mut self, name: &'static str, t: P<Type>) -> P<Symbol> | checker.go:14319 | Checker
new_property | pub(crate) fn new_property(&mut self, name: &'static str, t: P<Type>) -> P<Symbol> | checker.go:14325 | Checker
new_result | pub fn new_result(value: Option<LiteralValue>, is_syntactically_string: bool, resolved_other_files: bool, has_external_references: bool) -> Result | rust:evaluator.rs:13 | -
new_setter_function_type | pub(crate) fn new_setter_function_type(&mut self, t: P<Type>) -> P<Type> | checker.go:31002 | Checker
new_signature | pub(crate) fn new_signature(&mut self, flags: SignatureFlags, declaration: Option<P<Node>>, type_parameters: &[P<Type>], this_parameter: Option<P<Symbol>>, parameters: &[P<Symbol>], resolved_return_type: Option<P<Type>>, resolved_type_predicate: Option<P<TypePredicate>>, min_argument_count: usize) -> P<Signature> | checker.go:25717 | Checker
new_simple_type_mapper | pub(crate) fn new_simple_type_mapper(source: P<Type>, target: P<Type>) -> P<TypeMapper> | rust:mapper.rs:513 | -
new_string_literal | pub(crate) fn new_string_literal(&self, c: &mut Checker, text: &str) -> P<Node> | nodebuilderimpl.go:3624 | NodeBuilderImpl
new_string_literal_ex | pub(crate) fn new_string_literal_ex(&self, _c: &mut Checker, text: &str, is_single_quote: bool) -> P<Node> | nodebuilderimpl.go:3628 | NodeBuilderImpl
new_string_mapping_type | pub(crate) fn new_string_mapping_type(&mut self, symbol: P<Symbol>, target: P<Type>) -> P<Type> | checker.go:25692 | Checker
new_substitution_type | pub(crate) fn new_substitution_type(&mut self, base_type: P<Type>, constraint: P<Type>) -> P<Type> | checker.go:25710 | Checker
new_symbol | pub(crate) fn new_symbol(&mut self, flags: SymbolFlags, name: &'static str) -> P<Symbol> | checker.go:14305 | Checker
new_symbol_ex | pub(crate) fn new_symbol_ex(&mut self, flags: SymbolFlags, name: &'static str, check_flags: CheckFlags) -> P<Symbol> | checker.go:14313 | Checker
new_symbol_tracker_impl | pub fn new_symbol_tracker_impl(context: P<NodeBuilderContext>, tracker: Option<&'static dyn SymbolTracker>) -> P<SymbolTrackerImpl> | symboltracker.go:14 | -
new_template_literal_type | pub(crate) fn new_template_literal_type(&mut self, texts: &[&str], types: &[P<Type>]) -> P<Type> | checker.go:25685 | Checker
new_type | pub(crate) fn new_type<T: TypePayload>(&mut self, flags: TypeFlags, object_flags: ObjectFlags, data: T) -> P<Type> | checker.go:25473 | Checker
new_type_mapper | pub(crate) fn new_type_mapper(sources: &'static [P<Type>], targets: &'static [P<Type>]) -> P<TypeMapper> | rust:mapper.rs:481 | -
new_type_parameter | pub(crate) fn new_type_parameter(&mut self, symbol: Option<P<Symbol>>) -> P<Type> | checker.go:25638 | Checker
new_type_predicate | pub(crate) fn new_type_predicate(kind: TypePredicateKind, parameter_name: &str, parameter_index: Option<usize>, t: Option<P<Type>>) -> P<TypePredicate> | relater.go:2141 | Checker
new_typed_property_descriptor_type | pub(crate) fn new_typed_property_descriptor_type(&mut self, property_type: P<Type>) -> P<Type> | checker.go:31013 | Checker
new_union_type | pub(crate) fn new_union_type(&mut self, object_flags: ObjectFlags, types: &[P<Type>]) -> P<Type> | checker.go:25658 | Checker
new_unique_es_symbol_type | pub(crate) fn new_unique_es_symbol_type(&mut self, symbol: P<Symbol>, name: &str) -> P<Type> | checker.go:25525 | Checker
new_wrapping_tracker | pub(crate) fn new_wrapping_tracker(inner: &'static dyn SymbolTracker, bound: P<recoveryBoundary>) -> P<wrappingTracker> | nodecopy.go:188 | -
next_serial | pub(crate) fn next_serial(&mut self) -> u32 | rust:flowmemo.rs:219 | FlowMemo
no_type_predicate | fn no_type_predicate(&self) -> bool | rust:types.rs:2992 | SignatureRareWord
node_immediately_references_super_or_this | pub(crate) fn node_immediately_references_super_or_this(node: P<Node>) -> bool | checker.go:2961 | -
node_label | fn node_label(node: P<Node>) -> String | rust:workcensus.rs:442 | -
node_starts_new_lexical_environment | pub(crate) fn node_starts_new_lexical_environment(node: P<Node>) -> bool | utilities.go:1763 | -
non_fixing_mapper | pub fn non_fixing_mapper(&self) -> Option<P<TypeMapper>> | rust:checker.rs:402 | InferenceContext
noop_add_visible_alias | pub(crate) fn noop_add_visible_alias(declaration: P<Node>, aliasing_statement: P<Node>) | emitresolver.go:382 | -
normalize | pub(crate) fn normalize(&mut self, c: &mut Checker, element_types: &[P<Type>], element_infos: &[TupleElementInfo]) -> bool | checker.go:23825 | TupleNormalizer
now | fn now(&self) -> u64 | rust:workcensus.rs:238 | Census
now_ns | pub fn now_ns(&self) -> u64 | rust:workcensus.rs:306 | Census
object_flags | pub fn object_flags(&self) -> ObjectFlags | rust:types.rs:1462 | Type
object_flags_lazy | pub fn object_flags_lazy(&self) -> ObjectFlags | rust:types.rs:1468 | Type
object_target | pub fn object_target(&self) -> Option<P<Type>> | rust:types.rs:1633 | Type
object_type | pub fn object_type(&self) -> Option<P<Type>> | rust:types.rs:2813 | IndexedAccessType
on_diagnostic_reported | pub(crate) fn on_diagnostic_reported(&self) | symboltracker.go:106 | SymbolTrackerImpl
on_failed_to_resolve_symbol | pub(crate) fn on_failed_to_resolve_symbol(&mut self, error_location: Option<P<Node>>, name: &str, meaning: SymbolFlags, name_not_found_message: &'static Message) | checker.go:1605 | Checker
on_reg_exp_scanner_errors | fn on_reg_exp_scanner_errors(c: &mut Checker, s: &mut Scanner, source_file: P<SourceFile>, last_error: &mut Option<P<Diagnostic>>) | rust:grammarchecks.rs:89 | -
on_successfully_resolved_symbol | pub(crate) fn on_successfully_resolved_symbol(&mut self, error_location: Option<P<Node>>, result: P<Symbol>, meaning: SymbolFlags, last_location: Option<P<Node>>, associated_declaration_for_containing_initializer_or_binding_name: Option<P<Node>>, within_deferred_context: bool) | checker.go:1861 | Checker
optional_chain_contains_reference | pub(crate) fn optional_chain_contains_reference(&mut self, source: P<Node>, target: P<Node>) -> bool | flow.go:1851 | Checker
origin | pub fn origin(&self) -> Option<P<Type>> | rust:types.rs:2661 | UnionType
outer_return_mapper | pub fn outer_return_mapper(&self) -> Option<P<TypeMapper>> | rust:checker.rs:442 | InferenceContext
outer_type_parameters | pub fn outer_type_parameters(&self) -> &'static [P<Type>] | rust:types.rs:2324 | InterfaceType
ov_symbol_table | pub fn ov_symbol_table(cell: &OvExact<Option<P<SymbolTable>>>) -> P<SymbolTable> | rust:types.rs:3395 | -
over | pub fn over(base: &'static Based<M, K>) -> Self | rust:basedmap.rs:29 | Based
own_lazy_member_table | pub(crate) fn own_lazy_member_table(&mut self, t: P<Type>, lm: P<LazyMemberTable>) -> P<LazyMemberTable> | rust:checker_09.rs:3096 | Checker
own_mappers | pub(crate) fn own_mappers(&self) -> [Option<P<TypeMapper>>; 2] | rust:checker.rs:384 | InferenceContext
owner | fn owner(&self) -> &Type | rust:types.rs:1224 | ObjectFlagsCell
pack_slice | fn pack_slice(s: &'static [P<Type>]) -> Option<usize> | rust:mapper.rs:148 | -
pack_slice | fn pack_slice(s: &'static [P<Type>]) -> Option<u64> | rust:mapper.rs:182 | -
packed_type_list_key | fn packed_type_list_key(tag: u64, types: &[P<Type>], flag: bool) -> Option<CacheHashKey> | rust:checker_09.rs:657 | -
pad_object_literal_type | pub(crate) fn pad_object_literal_type(&mut self, t: P<Type>, pattern: P<Node>) -> P<Type> | checker.go:17146 | Checker
pad_tuple_type | pub(crate) fn pad_tuple_type(&mut self, t: P<Type>, pattern: P<Node>) -> P<Type> | checker.go:17182 | Checker
pair | pub(crate) fn pair(source: TypeId, target: TypeId, intersection_state: IntersectionState) -> Option<RelationKey> | rust:relater_types.rs:145 | RelationKey
pair_slot_hash | fn pair_slot_hash(key: u64) -> u64 | rust:relater_1.rs:37 | -
parameter_index | pub fn parameter_index(&self) -> Option<usize> | rust:types.rs:3132 | TypePredicate
parameter_initializer_contains_undefined | pub(crate) fn parameter_initializer_contains_undefined(&mut self, declaration: P<Node>) -> bool | checker.go:11419 | Checker
parameter_name | pub fn parameter_name(&self) -> &'static str | rust:types.rs:3136 | TypePredicate
parameter_to_parameter_declaration_name | pub(crate) fn parameter_to_parameter_declaration_name(&self, c: &mut Checker, parameter_symbol: P<Symbol>, parameter_declaration: Option<P<Node>>) -> P<Node> | nodebuilderimpl.go:1763 | NodeBuilderImpl
parameters | pub fn parameters(&self) -> &'static [P<Symbol>] | rust:types.rs:3085 | Signature
parse_big_int_literal_type | pub(crate) fn parse_big_int_literal_type(&mut self, text: &str) -> P<Type> | checker.go:25812 | Checker
parse_isolated_entity_name | pub(crate) fn parse_isolated_entity_name(name: &str) -> Option<P<Node>> | jsx.go:1435 | Checker
payload | fn payload<T: TypePayload>(&self) -> &'static T | rust:types.rs:1410 | Type
permissive_mapper_worker | pub(crate) fn permissive_mapper_worker(&mut self, t: P<Type>) -> P<Type> | checker.go:25002 | Checker
pick_longest_candidate_signature | pub(crate) fn pick_longest_candidate_signature(&mut self, node: P<Node>, candidates: &mut [P<Signature>], args: &[P<Node>], check_mode: CheckMode) -> P<Signature> | checker.go:9702 | Checker
pop_active_mapper | pub(crate) fn pop_active_mapper(&mut self) | checker.go:22586 | Checker
pop_context | pub(crate) fn pop_context(&self) | nodebuilder.go:74 | NodeBuilder
pop_contextual_type | pub(crate) fn pop_contextual_type(&mut self) | checker.go:31369 | Checker
pop_error_fallback_node | pub fn pop_error_fallback_node(&self) | symboltracker.go:124 | SymbolTrackerImpl
pop_error_fallback_node | pub fn pop_error_fallback_node(&self) | nodecopy.go:139 | wrappingTracker
pop_inference_context | pub(crate) fn pop_inference_context(&mut self) | checker.go:31448 | Checker
pop_type_resolution | pub(crate) fn pop_type_resolution(&mut self) -> bool | checker.go:19119 | Checker
pragma_factory_argument | fn pragma_factory_argument(pragma: &'static Pragma) -> &'static str | rust:jsx.rs:1607 | -
precalculate_declaration_emit_visibility | pub fn precalculate_declaration_emit_visibility(&self, c: &mut Checker, file: P<SourceFile>) | emitresolver.go:236 | EmitResolver
prepare_lazy_members | pub(crate) fn prepare_lazy_members(&mut self, t: P<Type>, lm: P<LazyMemberTable>, this_argument: Option<P<Type>>) | rust:checker_09.rs:3057 | Checker
prepend_type_mapping | pub(crate) fn prepend_type_mapping(source: P<Type>, target: P<Type>, mapper: Option<P<TypeMapper>>) -> P<TypeMapper> | rust:mapper.rs:497 | -
primitive_type_alias_suggestions | pub fn primitive_type_alias_suggestions() -> &'static [(&'static str, P<Symbol>)] | rust:checker.rs:2934 | -
produce_deferred_diagnostics | pub(crate) fn produce_deferred_diagnostics(&mut self) | checker.go:14214 | Checker
propagate_optional_type_marker | pub(crate) fn propagate_optional_type_marker(&mut self, t: P<Type>, node: P<Node>, was_optional: bool) -> P<Type> | checker.go:29552 | Checker
propagate_verbosity_out | pub(crate) fn propagate_verbosity_out(&self) | nodebuilder.go:62 | NodeBuilder
properties | pub fn properties(&self) -> &'static [P<Symbol>] | rust:types.rs:2133 | StructuredType
properties_identical_to | pub(crate) fn properties_identical_to(&self, c: &mut Checker, source: P<Type>, target: P<Type>, excluded_properties: &Set<String>) -> Ternary | relater.go:4449 | Relater
properties_related_to | pub(crate) fn properties_related_to(&self, c: &mut Checker, source: P<Type>, target: P<Type>, report_errors: bool, excluded_properties: &Set<String>, optionals_only: bool, intersection_state: IntersectionState) -> Ternary | relater.go:4132 | Relater
properties_related_to_rest | fn properties_related_to_rest(&self, c: &mut Checker, source: P<Type>, target: P<Type>, report_errors: bool, excluded_properties: &Set<String>, optionals_only: bool, intersection_state: IntersectionState, require_optional_properties: bool, unmatched_property: Option<P<Symbol>>, found: &[Option<Option<P<Symbol>>>]) -> Ternary | rust:relater_2.rs:2181 | Relater
properties_table | fn properties_table(&self) -> P<SymbolTable> | rust:checker_07.rs:33 | ObjectLiteralState
properties_table_for | fn properties_table_for(&self, capacity: usize) -> P<SymbolTable> | rust:checker_07.rs:38 | ObjectLiteralState
property_cache | pub fn property_cache(&self, skip_object_function_property_augment: bool) -> Option<P<SymbolTable>> | rust:types.rs:2600 | UnionOrIntersectionType
property_cache_for_write | pub fn property_cache_for_write(&self, skip_object_function_property_augment: bool) -> P<SymbolTable> | rust:types.rs:2606 | UnionOrIntersectionType
property_related_to | pub(crate) fn property_related_to(&self, c: &mut Checker, source: P<Type>, target: P<Type>, source_prop: P<Symbol>, target_prop: P<Symbol>, get_type_of_source_property: impl FnMut(&mut Checker, P<Symbol>) -> P<Type>, report_errors: bool, intersection_state: IntersectionState, skip_optional: bool) -> Ternary | relater.go:4302 | Relater
pseudo_big_int_to_string | pub(crate) fn pseudo_big_int_to_string(value: PseudoBigInt) -> String | utilities.go:1228 | -
pseudo_parameter_to_node | pub(crate) fn pseudo_parameter_to_node(&self, c: &mut Checker, p: P<PseudoParameter>) -> P<Node> | pseudotypenodebuilder.go:335 | NodeBuilderImpl
pseudo_parameters_equivalent_to_parameters | pub(crate) fn pseudo_parameters_equivalent_to_parameters(&self, c: &mut Checker, params: &[P<PseudoParameter>], target_sig: P<Signature>, report_errors: bool, non_param_error_location: P<Node>) -> bool | pseudotypenodebuilder.go:585 | NodeBuilderImpl
pseudo_parameters_to_node_list | pub(crate) fn pseudo_parameters_to_node_list(&self, c: &mut Checker, params: &[P<PseudoParameter>]) -> P<NodeList> | pseudotypenodebuilder.go:327 | NodeBuilderImpl
pseudo_return_type_matches_predicate | pub(crate) fn pseudo_return_type_matches_predicate(c: &mut Checker, rt: Option<P<PseudoType>>, predicate: P<TypePredicate>) -> bool | pseudotypenodebuilder.go:645 | NodeBuilderImpl
pseudo_type_equivalent_to_type | pub(crate) fn pseudo_type_equivalent_to_type(&self, c: &mut Checker, t: Option<P<PseudoType>>, type_: Option<P<Type>>, is_optional_annotated: bool, report_errors: bool) -> bool | pseudotypenodebuilder.go:362 | NodeBuilderImpl
pseudo_type_to_node | pub(crate) fn pseudo_type_to_node(&self, c: &mut Checker, t: Option<P<PseudoType>>) -> Option<P<Node>> | pseudotypenodebuilder.go:48 | NodeBuilderImpl
pseudo_type_to_node_with_checker_fallback | pub(crate) fn pseudo_type_to_node_with_checker_fallback(&self, c: &mut Checker, t: P<PseudoType>, checker_type: P<Type>) -> Option<P<Node>> | pseudotypenodebuilder.go:15 | NodeBuilderImpl
pseudo_type_to_type | pub(crate) fn pseudo_type_to_type(c: &mut Checker, t: Option<P<PseudoType>>) -> Option<P<Type>> | pseudotypenodebuilder.go:689 | NodeBuilderImpl
push | pub fn push(&self, item: T) | rust:checker.rs:572 | LazyVec
push_active_mapper | pub(crate) fn push_active_mapper(&mut self, mapper: P<TypeMapper>) | checker.go:22571 | Checker
push_cached_contextual_type | pub(crate) fn push_cached_contextual_type(&mut self, node: P<Node>) | checker.go:31361 | Checker
push_contextual_type | pub(crate) fn push_contextual_type(&mut self, node: P<Node>, t: Option<P<Type>>, is_cache: bool) | checker.go:31365 | Checker
push_error_fallback_node | pub fn push_error_fallback_node(&self, node: Option<P<Node>>) | symboltracker.go:117 | SymbolTrackerImpl
push_error_fallback_node | pub fn push_error_fallback_node(&self, node: Option<P<Node>>) | nodecopy.go:143 | wrappingTracker
push_fake_scope | fn push_fake_scope(b: &NodeBuilderImpl, c: &mut Checker, kind: &'static str, add_all: &mut dyn FnMut(&NodeBuilderImpl, &mut Checker, AddSymbol)) -> Option<Box<dyn FnMut()>> | rust:nodebuilderscopes.rs:155 | -
push_inference_context | pub(crate) fn push_inference_context(&mut self, node: P<Node>, context: Option<P<InferenceContext>>) | checker.go:31444 | Checker
push_intra_expression_inference_site | pub fn push_intra_expression_inference_site(&self, site: IntraExpressionInferenceSite) | rust:checker.rs:469 | InferenceContext
push_template_string_for_type | pub(crate) fn push_template_string_for_type(sb: &mut String, t: P<Type>) | checker.go:29702 | Checker
push_type_resolution | pub(crate) fn push_type_resolution(&mut self, target: TypeSystemEntity, property_name: TypeSystemPropertyName) -> bool | checker.go:19102 | Checker
put_flow_state | pub(crate) fn put_flow_state(&mut self, f: P<FlowState>) | flow.go:61 | Checker
put_inference_state | pub(crate) fn put_inference_state(&mut self, n: P<InferenceState>) | inference.go:41 | Checker
put_relater | pub(crate) fn put_relater(&mut self, r: P<Relater>) | relater.go:2608 | Checker
quoted_and_comma_separated | pub(crate) fn quoted_and_comma_separated(items: &[&str]) -> String | utilities.go:1923 | -
raise_height | pub(crate) fn raise_height(&mut self, height: u16) | rust:flowmemo.rs:280 | FlowMemo
range_of_type_parameters | pub(crate) fn range_of_type_parameters(source_file: P<SourceFile>, type_parameters: P<NodeList>) -> TextRange | utilities.go:1609 | -
rare | fn rare(&self) -> Option<P<InferenceContextRare>> | rust:checker.rs:361 | InferenceContext
rare | fn rare(&self) -> Option<&'static UnionOrIntersectionRare> | rust:types.rs:2564 | UnionOrIntersectionType
rare_for_write | fn rare_for_write(&self) -> P<InferenceContextRare> | rust:checker.rs:420 | InferenceContext
rare_for_write | fn rare_for_write(&self) -> P<SignatureRare> | rust:types.rs:3029 | Signature
rare_for_write | fn rare_for_write(&self) -> &'static UnionOrIntersectionRare | rust:types.rs:2573 | UnionOrIntersectionType
reborrow_reporter | fn reborrow_reporter<'b>(r: &'b mut Option<ErrorReporter<'_>>) -> Option<ErrorReporter<'b>> | rust:relater_1.rs:16 | -
recombine_unknown_type | pub(crate) fn recombine_unknown_type(&self, t: P<Type>) -> P<Type> | checker.go:31690 | Checker
record | pub fn record(&mut self, cat: Cat, key: CKey, t: Timing, a: u64, b: u64, c: u64) | rust:workcensus.rs:277 | Census
record | fn record(self) -> Option<P<TypeSymbolAlias>> | rust:types.rs:1285 | TypeSymbolWord
record_merged_symbol | pub(crate) fn record_merged_symbol(&mut self, target: P<Symbol>, source: P<Symbol>) | checker.go:14601 | Checker
record_potential_collision_with_reflect_in_generated_code | pub(crate) fn record_potential_collision_with_reflect_in_generated_code(&mut self, node: P<Node>, name: Option<P<Node>>) | checker.go:10771 | Checker
record_potential_collision_with_weak_map_set_in_generated_code | pub(crate) fn record_potential_collision_with_weak_map_set_in_generated_code(&mut self, node: P<Node>, name: P<Node>) | checker.go:10736 | Checker
recursion_key | fn recursion_key(identity: RecursionId) -> u64 | rust:relater_1.rs:1236 | -
recursive_type_related_to | pub(crate) fn recursive_type_related_to(&self, c: &mut Checker, source: P<Type>, target: P<Type>, report_errors: bool, intersection_state: IntersectionState, recursion_flags: RecursionFlags) -> Ternary | relater.go:3094 | Relater
recycle | pub(crate) fn recycle(n: P<InferenceContext>) | rust:checker.rs:482 | InferenceContext
recycle | pub(crate) fn recycle(&self) | rust:checker.rs:594 | LazyVec
recycle_held_mapper | fn recycle_held_mapper(m: P<TypeMapper>) | rust:checker.rs:537 | InferenceContext
recycle_mapper | pub(crate) unsafe fn recycle_mapper(m: P<TypeMapper>) | rust:mapper.rs:354 | -
recycle_mapper_with_targets | pub(crate) unsafe fn recycle_mapper_with_targets(m: P<TypeMapper>, targets: *const [P<Type>]) | rust:mapper.rs:389 | -
recycle_mapping | pub(crate) unsafe fn recycle_mapping(m: P<TypeMapper>, appended: bool) | rust:mapper.rs:365 | -
ref_node | fn ref_node(&self) -> P<Node> | rust:flow.rs:19 | FlowState
reference_kinds | pub(crate) fn reference_kinds(&self, symbol: P<Symbol>) -> SymbolFlags | rust:checker_01.rs:609 | Checker
reference_kinds | pub fn reference_kinds(&self, symbol: P<Symbol>) -> SymbolFlags | rust:links.rs:343 | SymbolReferenceLinkStore
register_for_unused_identifiers_check | pub(crate) fn register_for_unused_identifiers_check(&mut self, node: P<Node>) | checker.go:7212 | Checker
regular_type | pub fn regular_type(&self) -> Option<P<Type>> | rust:types.rs:1999 | LiteralType
regular_type | pub fn regular_type(&self) -> Option<P<Type>> | rust:types.rs:2651 | UnionType
rel | pub(crate) fn rel(&self) -> P<Relation> | rust:relater_2.rs:58 | Relater
rel_kind | pub(crate) fn rel_kind(c: &Checker, rel: P<crate::relater_types::Relation>) -> u8 | rust:workcensus.rs:328 | -
relate_variances | fn relate_variances(&self, c: &mut Checker, source_type_arguments: &[P<Type>], target_type_arguments: &[P<Type>], variances: &[VarianceFlags], intersection_state: IntersectionState, report_errors: bool, save_error_state: &errorState, result: &mut Ternary, variance_check_failed: &mut bool, original_error_chain: &mut Option<P<ErrorChain>>) -> (Ternary, bool) | rust:relater_2.rs:1064 | Relater
relation_cache_entries | pub fn relation_cache_entries(&self) -> usize | rust:checker.rs:3098 | Checker
relative | fn relative(name: &str) -> &str | rust:uniontrace.rs:110 | -
remove | pub fn remove(&mut self, key: &K) -> Option<V> | rust:basedmap.rs:93 | Based
remove_constrained_type_variables | pub(crate) fn remove_constrained_type_variables(&mut self, types: &[P<Type>]) -> Vec<P<Type>> | checker.go:26351 | Checker
remove_definitely_falsy_types | pub fn remove_definitely_falsy_types(&mut self, t: P<Type>) -> P<Type> | checker.go:29576 | Checker
remove_missing_or_undefined_type | pub fn remove_missing_or_undefined_type(&mut self, t: P<Type>) -> P<Type> | checker.go:29569 | Checker
remove_missing_or_undefined_type_exported | pub fn remove_missing_or_undefined_type_exported(&mut self, t: P<Type>) -> P<Type> | exports.go:386 | Checker
remove_missing_type | pub(crate) fn remove_missing_type(&mut self, t: P<Type>, is_optional: bool) -> P<Type> | checker.go:29562 | Checker
remove_nullable_by_intersection | pub(crate) fn remove_nullable_by_intersection(&mut self, t: P<Type>, target_facts: TypeFacts, other_facts: TypeFacts, other_includes_facts: TypeFacts, other_type: P<Type>) -> P<Type> | checker.go:31668 | Checker
remove_optional_type_marker | pub(crate) fn remove_optional_type_marker(&mut self, t: P<Type>) -> P<Type> | checker.go:29545 | Checker
remove_optionality_from_declared_type | pub(crate) fn remove_optionality_from_declared_type(&mut self, declared_type: P<Type>, declaration: P<Node>) -> P<Type> | checker.go:11411 | Checker
remove_redundant_literal_types | pub(crate) fn remove_redundant_literal_types(&mut self, types: &[P<Type>], includes: TypeFlags, reduce_void_undefined: bool) -> Vec<P<Type>> | checker.go:26308 | Checker
remove_redundant_supertypes | pub(crate) fn remove_redundant_supertypes(&mut self, types: &mut Vec<P<Type>>, includes: TypeFlags) | checker.go:26765 | Checker
remove_string_literals_matched_by_template_literals | pub(crate) fn remove_string_literals_matched_by_template_literals(&mut self, types: &[P<Type>]) -> Vec<P<Type>> | checker.go:26327 | Checker
remove_subtypes | pub(crate) fn remove_subtypes(&mut self, types: &[P<Type>], has_object_types: bool) -> Option<Vec<P<Type>>> | checker.go:26404 | Checker
remove_subtypes_inner | fn remove_subtypes_inner(&mut self, types: &[P<Type>], has_object_types: bool) -> Option<Vec<P<Type>>> | rust:checker_13.rs:425 | Checker
remove_type | pub(crate) fn remove_type(&mut self, t: P<Type>, target_type: P<Type>) -> P<Type> | checker.go:27064 | Checker
reorder_candidates | pub(crate) fn reorder_candidates(&mut self, signatures: &[P<Signature>], call_chain_flags: SignatureFlags) -> Vec<P<Signature>> | checker.go:9145 | Checker
replace_indexed_access | pub(crate) fn replace_indexed_access(&mut self, instantiable: P<Type>, t: P<Type>, replacement: P<Type>) -> P<Type> | inference.go:1178 | Checker
replace_primitives_with_literals | pub(crate) fn replace_primitives_with_literals(&mut self, type_with_primitives: P<Type>, type_with_literals: P<Type>) -> P<Type> | flow.go:1907 | Checker
report | pub(crate) fn report(c: &Checker, input: &[P<Type>], kept: &[P<Type>], verdict: &str, comparisons: Option<i64>, checkpoint: Option<Checkpoint>) | rust:uniontrace.rs:43 | -
report | pub fn report(&self) -> Option<String> | rust:flowmemo.rs:352 | FlowMemo
report_call_resolution_errors | pub(crate) fn report_call_resolution_errors(&mut self, node: P<Node>, s: &CallState, signatures: &[P<Signature>], head_message: Option<&'static Message>) | checker.go:9841 | Checker
report_cannot_invoke_possibly_null_or_undefined_error | pub(crate) fn report_cannot_invoke_possibly_null_or_undefined_error(&mut self, node: P<Node>, facts: TypeFacts) | checker.go:10086 | Checker
report_check_file | pub(crate) fn report_check_file(c: &Checker, file: P<SourceFile>, piece: Option<&std::ops::Range<usize>>) | rust:uniontrace.rs:89 | -
report_circular_base_type | pub(crate) fn report_circular_base_type(&mut self, node: P<Node>, t: P<Type>) | checker.go:19873 | Checker
report_circularity_error | pub(crate) fn report_circularity_error(&mut self, symbol: P<Symbol>) -> P<Type> | checker.go:19166 | Checker
report_cross_product | pub(crate) fn report_cross_product(c: &Checker, types: &[P<Type>], size: usize) | rust:uniontrace.rs:69 | -
report_cyclic_structure_error | pub fn report_cyclic_structure_error(&self) | symboltracker.go:66 | SymbolTrackerImpl
report_cyclic_structure_error | pub fn report_cyclic_structure_error(&self) | nodecopy.go:147 | wrappingTracker
report_diagnostic | pub(crate) fn report_diagnostic(&mut self, diagnostic: Option<P<Diagnostic>>, diagnostic_output: Option<&mut Vec<P<Diagnostic>>>) | relater.go:414 | Checker
report_duplicate_member_errors | pub(crate) fn report_duplicate_member_errors(&mut self, node: P<Node>, name: &str, check_static: bool, is_static: bool, message: &'static Message) | checker.go:3261 | Checker
report_error | pub(crate) fn report_error(&self, c: &mut Checker, message: &'static Message, args: &[&dyn Display]) | relater.go:4864 | Relater
report_error_results | pub(crate) fn report_error_results(&self, c: &mut Checker, original_source: P<Type>, original_target: P<Type>, source: P<Type>, target: P<Type>, head_message: Option<&'static Message>) | relater.go:4737 | Relater
report_errors_from_widening | pub(crate) fn report_errors_from_widening(&mut self, declaration: P<Node>, t: P<Type>, widening_kind: WideningKind) | checker.go:20793 | Checker
report_flow_control_error | pub(crate) fn report_flow_control_error(&mut self, node: P<Node>) | flow.go:1590 | Checker
report_implicit_any | pub(crate) fn report_implicit_any(&mut self, declaration: P<Node>, t: P<Type>, widening_kind: WideningKind) | checker.go:18615 | Checker
report_inaccessible_this_error | pub fn report_inaccessible_this_error(&self) | symboltracker.go:42 | SymbolTrackerImpl
report_inaccessible_this_error | pub fn report_inaccessible_this_error(&self) | nodecopy.go:151 | wrappingTracker
report_inaccessible_unique_symbol_error | pub fn report_inaccessible_unique_symbol_error(&self) | symboltracker.go:58 | SymbolTrackerImpl
report_inaccessible_unique_symbol_error | pub fn report_inaccessible_unique_symbol_error(&self) | nodecopy.go:155 | wrappingTracker
report_inference_fallback | pub fn report_inference_fallback(&self, c: &mut Checker, node: P<Node>) | symboltracker.go:110 | SymbolTrackerImpl
report_inference_fallback | pub fn report_inference_fallback(&self, c: &mut Checker, node: P<Node>) | nodecopy.go:159 | wrappingTracker
report_invalid_import_equals_export_member | pub(crate) fn report_invalid_import_equals_export_member(&mut self, name: P<Node>, declaration_name: &str, module_name: &str) | checker.go:15184 | Checker
report_likely_unsafe_import_required_error | pub fn report_likely_unsafe_import_required_error(&self, specifier: &str, symbol_name: &str) | symboltracker.go:74 | SymbolTrackerImpl
report_likely_unsafe_import_required_error | pub fn report_likely_unsafe_import_required_error(&self, specifier: &str, symbol_name: &str) | nodecopy.go:163 | wrappingTracker
report_merge_symbol_error | pub(crate) fn report_merge_symbol_error(&mut self, target: P<Symbol>, source: P<Symbol>) | checker.go:14436 | Checker
report_non_default_export | pub(crate) fn report_non_default_export(&mut self, module_symbol: P<Symbol>, node: P<Node>) | checker.go:14829 | Checker
report_non_exported_member | pub(crate) fn report_non_exported_member(&mut self, name: P<Node>, declaration_name: &str, module_symbol: P<Symbol>, module_name: &str) | checker.go:15152 | Checker
report_non_serializable_property | pub fn report_non_serializable_property(&self, property_name: &str) | symboltracker.go:98 | SymbolTrackerImpl
report_non_serializable_property | pub fn report_non_serializable_property(&self, property_name: &str) | nodecopy.go:167 | wrappingTracker
report_nonexistent_property | pub(crate) fn report_nonexistent_property(&mut self, prop_node: P<Node>, containing_type: P<Type>, is_unchecked_js: bool) | checker.go:11731 | Checker
report_nonlocal_augmentation | pub fn report_nonlocal_augmentation(&self, containing_file: P<SourceFile>, parent_symbol: P<Symbol>, augmenting_symbol: P<Symbol>) | symboltracker.go:90 | SymbolTrackerImpl
report_nonlocal_augmentation | pub fn report_nonlocal_augmentation(&self, containing_file: P<SourceFile>, parent_symbol: P<Symbol>, augmenting_symbol: P<Symbol>) | nodecopy.go:171 | wrappingTracker
report_object_possibly_null_or_undefined_error | pub(crate) fn report_object_possibly_null_or_undefined_error(&mut self, node: P<Node>, facts: TypeFacts) | checker.go:7628 | Checker
report_obvious_decorator_errors | pub(crate) fn report_obvious_decorator_errors(&mut self, node: P<Node>) -> bool | grammarchecks.go:642 | Checker
report_obvious_modifier_errors | pub(crate) fn report_obvious_modifier_errors(&mut self, node: P<Node>) -> bool | grammarchecks.go:571 | Checker
report_operator_error | pub(crate) fn report_operator_error(&mut self, left_type: P<Type>, operator: Kind, right_type: P<Type>, error_node: Option<P<Node>>, is_related: Option<&mut dyn FnMut(&mut Checker, P<Type>, P<Type>) -> bool>) | checker.go:12926 | Checker
report_operator_error_unless | pub(crate) fn report_operator_error_unless(&mut self, left_type: P<Type>, operator: Kind, right_type: P<Type>, error_node: Option<P<Node>>, types_are_compatible: impl FnMut(&mut Checker, P<Type>, P<Type>) -> bool) | checker.go:12947 | Checker
report_private_in_base_of_class_expression | pub fn report_private_in_base_of_class_expression(&self, property_name: &str) | symboltracker.go:50 | SymbolTrackerImpl
report_private_in_base_of_class_expression | pub fn report_private_in_base_of_class_expression(&self, property_name: &str) | nodecopy.go:175 | wrappingTracker
report_relation_error | pub(crate) fn report_relation_error(&self, c: &mut Checker, message: Option<&'static Message>, source: P<Type>, target: P<Type>) | relater.go:4783 | Relater
report_too_complex | pub(crate) fn report_too_complex(&mut self, key: u64) | rust:checker_13.rs:1450 | Checker
report_truncation_error | pub fn report_truncation_error(&self) | symboltracker.go:82 | SymbolTrackerImpl
report_truncation_error | pub fn report_truncation_error(&self) | nodecopy.go:179 | wrappingTracker
report_type_not_iterable_error | pub(crate) fn report_type_not_iterable_error(&mut self, error_node: P<Node>, t: P<Type>, allow_async_iterables: bool) -> P<Diagnostic> | checker.go:6869 | Checker
report_unmatched_property | pub(crate) fn report_unmatched_property(&self, c: &mut Checker, source: P<Type>, target: P<Type>, unmatched_property: P<Symbol>, require_optional_properties: bool) | relater.go:4377 | Relater
report_unmeasurable_worker | pub(crate) fn report_unmeasurable_worker(&mut self, t: P<Type>) -> P<Type> | checker.go:1153 | Checker
report_unreliable_worker | pub(crate) fn report_unreliable_worker(&mut self, t: P<Type>) -> P<Type> | checker.go:1146 | Checker
report_unused | pub(crate) fn report_unused(&mut self, location: P<Node>, kind: UnusedKind, diagnostic: P<Diagnostic>) | checker.go:7263 | Checker
report_unused_binding_elements | pub(crate) fn report_unused_binding_elements(&mut self, node: P<Node>) | checker.go:7371 | Checker
report_unused_imports | pub(crate) fn report_unused_imports(&mut self, node: P<Node>, unuseds: &[P<Node>]) | checker.go:7420 | Checker
report_unused_local | pub(crate) fn report_unused_local(&mut self, node: P<Node>, name: &str) | checker.go:7353 | Checker
report_unused_parameters | pub(crate) fn report_unused_parameters(&mut self, node: P<Node>) | checker.go:7367 | Checker
report_unused_variable | pub(crate) fn report_unused_variable(&mut self, location: P<Node>, diagnostic: P<Diagnostic>) | checker.go:7256 | Checker
report_unused_variable_declarations | pub(crate) fn report_unused_variable_declarations(&mut self, declarations: &[P<Node>]) | checker.go:7380 | Checker
report_unused_variables | pub(crate) fn report_unused_variables(&mut self, node: P<Node>) | checker.go:7358 | Checker
report_widening_errors_in_type | pub(crate) fn report_widening_errors_in_type(&mut self, t: P<Type>) -> bool | checker.go:20838 | Checker
reports_interface_check_errors | fn reports_interface_check_errors(&mut self, symbol: P<Symbol>, node: P<Node>, t: P<Type>) -> bool | rust:checker_03.rs:996 | Checker
requires_adding_implicit_undefined | pub fn requires_adding_implicit_undefined(&mut self, node: P<Node>) -> bool | exports.go:374 | Checker
requires_adding_implicit_undefined | pub(crate) fn requires_adding_implicit_undefined(&self, c: &mut Checker, declaration: P<Node>, symbol: Option<P<Symbol>>, enclosing_declaration: Option<P<Node>>) -> bool | emitresolver.go:585 | EmitResolver
requires_adding_implicit_undefined_exported | pub fn requires_adding_implicit_undefined_exported(&self, c: &mut Checker, declaration: P<Node>, symbol: Option<P<Symbol>>, enclosing_declaration: Option<P<Node>>) -> bool | emitresolver.go:568 | EmitResolver
requires_adding_implicit_undefined_unsafe | pub fn requires_adding_implicit_undefined_unsafe(&self, c: &mut Checker, declaration: P<Node>, symbol: Option<P<Symbol>>, enclosing_declaration: Option<P<Node>>) -> bool | emitresolver.go:577 | EmitResolver
requires_adding_implicit_undefined_worker | pub(crate) fn requires_adding_implicit_undefined_worker(&self, c: &mut Checker, parameter: P<Node>, enclosing_declaration: Option<P<Node>>) -> bool | emitresolver.go:605 | EmitResolver
reset_maybe_stack | pub(crate) fn reset_maybe_stack(&self, _c: &mut Checker, maybe_start: usize, propagating_variance_flags: RelationComparisonResult, mark_all_as_succeeded: bool) | relater.go:3201 | Relater
resolution_extension_is_ts_or_json | pub(crate) fn resolution_extension_is_ts_or_json(ext: &str) -> bool | checker.go:15748 | -
resolve_alias | pub(crate) fn resolve_alias(&mut self, symbol: P<Symbol>) -> P<Symbol> | checker.go:16589 | Checker
resolve_alias_exported | pub fn resolve_alias_exported(&mut self, symbol: Option<P<Symbol>>) -> (Option<P<Symbol>>, bool) | checker.go:16578 | Checker
resolve_alias_with_deprecation_check | pub(crate) fn resolve_alias_with_deprecation_check(&mut self, symbol: P<Symbol>, location: P<Node>) -> P<Symbol> | checker.go:16634 | Checker
resolve_anonymous_type_members | pub(crate) fn resolve_anonymous_type_members(&mut self, t: P<Type>) | checker.go:20991 | Checker
resolve_base_types_of_class | pub(crate) fn resolve_base_types_of_class(&mut self, t: P<Type>) | checker.go:19561 | Checker
resolve_base_types_of_interface | pub(crate) fn resolve_base_types_of_interface(&mut self, t: P<Type>) | checker.go:19839 | Checker
resolve_call | pub(crate) fn resolve_call(&mut self, node: P<Node>, signatures: &[P<Signature>], candidates_out_array: Option<&mut Vec<P<Signature>>>, check_mode: CheckMode, call_chain_flags: SignatureFlags, head_message: Option<&'static Message>) -> P<Signature> | checker.go:9028 | Checker
resolve_call_expression | pub(crate) fn resolve_call_expression(&mut self, node: P<Node>, candidates_out_array: Option<&mut Vec<P<Signature>>>, check_mode: CheckMode) -> P<Signature> | checker.go:8645 | Checker
resolve_call_worker | fn resolve_call_worker(&mut self, node: P<Node>, signatures: &[P<Signature>], candidates_out_array: Option<&mut Vec<P<Signature>>>, check_mode: CheckMode, call_chain_flags: SignatureFlags, head_message: Option<&'static Message>) -> P<Signature> | rust:checker_05.rs:345 | Checker
resolve_class_or_interface_members | pub(crate) fn resolve_class_or_interface_members(&mut self, t: P<Type>) | checker.go:19435 | Checker
resolve_components | pub fn resolve_components(c: &mut Checker, typ: P<Type>) | rust:types.rs:2466 | MappedType
resolve_declared_members | pub(crate) fn resolve_declared_members(&mut self, t: P<Type>) -> &'static InterfaceType | checker.go:19953 | Checker
resolve_decorator | pub(crate) fn resolve_decorator(&mut self, node: P<Node>, candidates_out_array: Option<&mut Vec<P<Signature>>>, check_mode: CheckMode) -> P<Signature> | checker.go:8927 | Checker
resolve_entity_name | pub(crate) fn resolve_entity_name(&mut self, name: P<Node>, meaning: SymbolFlags, ignore_errors: bool, dont_resolve_alias: bool, location: Option<P<Node>>) -> Option<P<Symbol>> | checker.go:16095 | Checker
resolve_error_call | pub(crate) fn resolve_error_call(&mut self, node: P<Node>) -> P<Signature> | checker.go:10115 | Checker
resolve_es_module_symbol | pub(crate) fn resolve_es_module_symbol(&mut self, module_symbol: P<Symbol>, node: P<Node>, module_specifier: P<Node>) -> P<Symbol> | checker.go:15891 | Checker
resolve_export_by_name | pub(crate) fn resolve_export_by_name(&mut self, module_symbol: P<Symbol>, name: &str, source_node: Option<P<Node>>, dont_resolve_alias: bool) -> Option<P<Symbol>> | checker.go:14853 | Checker
resolve_external_module | pub(crate) fn resolve_external_module(&mut self, location: Option<P<Node>>, module_reference: &str, module_not_found_error: Option<&'static Message>, error_node: Option<P<Node>>, is_for_augmentation: bool, import_attributes_type: Option<P<Type>>) -> Option<P<Symbol>> | checker.go:15399 | Checker
resolve_external_module_name | pub(crate) fn resolve_external_module_name(&mut self, location: P<Node>, module_reference_expression: P<Node>, ignore_errors: bool, import_attributes_type: Option<P<Type>>) -> Option<P<Symbol>> | checker.go:15344 | Checker
resolve_external_module_name_exported | pub fn resolve_external_module_name_exported(&mut self, module_specifier: P<Node>, import_attributes_type: Option<P<Type>>) -> Option<P<Symbol>> | exports.go:123 | Checker
resolve_external_module_name_worker | pub(crate) fn resolve_external_module_name_worker(&mut self, location: Option<P<Node>>, module_reference_expression: Option<P<Node>>, module_not_found_error: Option<&'static Message>, ignore_errors: bool, is_for_augmentation: bool, import_attributes_type: Option<P<Type>>) -> Option<P<Symbol>> | checker.go:15365 | Checker
resolve_external_module_symbol | pub(crate) fn resolve_external_module_symbol(&mut self, module_symbol: P<Symbol>, dont_resolve_alias: bool) -> P<Symbol> | checker.go:15879 | Checker
resolve_external_module_symbol_exported | pub fn resolve_external_module_symbol_exported(&mut self, module_symbol: P<Symbol>) -> P<Symbol> | exports.go:127 | Checker
resolve_external_module_type_by_literal | pub(crate) fn resolve_external_module_type_by_literal(&mut self, name: P<Node>) -> P<Type> | checker.go:14691 | Checker
resolve_helpers_module | pub(crate) fn resolve_helpers_module(&mut self, file: P<SourceFile>, error_node: P<Node>) -> P<Symbol> | checker.go:29143 | Checker
resolve_import_symbol_type | pub(crate) fn resolve_import_symbol_type(&mut self, node: P<Node>, symbol: P<Symbol>, meaning: SymbolFlags) -> P<Type> | checker.go:25127 | Checker
resolve_indirection_alias | pub(crate) fn resolve_indirection_alias(&mut self, source: P<Symbol>, target: P<Symbol>) -> P<Symbol> | checker.go:16616 | Checker
resolve_instanceof_expression | pub(crate) fn resolve_instanceof_expression(&mut self, node: P<Node>, candidates_out_array: Option<&mut Vec<P<Signature>>>, check_mode: CheckMode) -> P<Signature> | checker.go:8984 | Checker
resolve_intersection_type_members | pub(crate) fn resolve_intersection_type_members(&mut self, t: P<Type>) | checker.go:21643 | Checker
resolve_iteration_type | pub fn resolve_iteration_type(&self, c: &mut Checker, t: P<Type>, error_node: Option<P<Node>>) -> Option<P<Type>> | rust:checker.rs:973 | IterationTypesResolver
resolve_jsdoc_member_name | pub(crate) fn resolve_jsdoc_member_name(&mut self, name: Option<P<Node>>) -> Option<P<Symbol>> | checker.go:2597 | Checker
resolve_jsx_opening_like_element | pub(crate) fn resolve_jsx_opening_like_element(&mut self, node: P<Node>, candidates_out_array: Option<&mut Vec<P<Signature>>>, check_mode: CheckMode) -> P<Signature> | jsx.go:545 | Checker
resolve_lazy_members | pub(crate) fn resolve_lazy_members(&mut self, t: P<Type>, lm: P<LazyMemberTable>) | rust:checker_09.rs:3113 | Checker
resolve_mapped_type_members | pub(crate) fn resolve_mapped_type_members(&mut self, t: P<Type>) | checker.go:21235 | Checker
resolve_name | pub(crate) fn resolve_name(&mut self, location: Option<P<Node>>, name: &str, meaning: SymbolFlags, name_not_found_message: Option<&'static Message>, is_use: bool, exclude_globals: bool) -> Option<P<Symbol>> | rust:checker.rs:2400 | Checker
resolve_name_exported | pub fn resolve_name_exported(&mut self, name: &str, location: impl Into<Option<P<Node>>>, meaning: SymbolFlags, exclude_globals: bool) -> Option<P<Symbol>> | exports.go:296 | Checker
resolve_name_for_symbol_suggestion | pub(crate) fn resolve_name_for_symbol_suggestion(&mut self, location: Option<P<Node>>, name: &str, meaning: SymbolFlags, name_not_found_message: Option<&'static Message>, is_use: bool, exclude_globals: bool) -> Option<P<Symbol>> | rust:checker.rs:2413 | Checker
resolve_new_expression | pub(crate) fn resolve_new_expression(&mut self, node: P<Node>, candidates_out_array: Option<&mut Vec<P<Signature>>>, check_mode: CheckMode) -> P<Signature> | checker.go:8749 | Checker
resolve_object_type_members | pub(crate) fn resolve_object_type_members(&mut self, t: P<Type>, source: P<Type>, type_parameters: &[P<Type>], type_arguments: &[P<Type>]) | checker.go:19450 | Checker
resolve_qualified_name | pub(crate) fn resolve_qualified_name(&mut self, name: P<Node>, left: P<Node>, right: P<Node>, meaning: SymbolFlags, ignore_errors: bool, location: Option<P<Node>>) -> Option<P<Symbol>> | checker.go:16151 | Checker
resolve_reverse_mapped_type_members | pub(crate) fn resolve_reverse_mapped_type_members(&mut self, t: P<Type>) | inference.go:1099 | Checker
resolve_signature | pub(crate) fn resolve_signature(&mut self, node: P<Node>, candidates_out_array: Option<&mut Vec<P<Signature>>>, check_mode: CheckMode) -> P<Signature> | checker.go:8627 | Checker
resolve_structured_type_members | pub(crate) fn resolve_structured_type_members(&mut self, t: P<Type>) -> &'static StructuredType | checker.go:19406 | Checker
resolve_structured_type_members_worker | fn resolve_structured_type_members_worker(&mut self, t: P<Type>) -> &'static StructuredType | rust:checker_09.rs:2714 | Checker
resolve_symbol | pub(crate) fn resolve_symbol(&mut self, symbol: P<Symbol>) -> P<Symbol> | checker.go:14657 | Checker
resolve_symbol_ex | pub(crate) fn resolve_symbol_ex(&mut self, symbol: P<Symbol>, dont_resolve_alias: bool) -> P<Symbol> | checker.go:14661 | Checker
resolve_tagged_template_expression | pub(crate) fn resolve_tagged_template_expression(&mut self, node: P<Node>, candidates_out_array: Option<&mut Vec<P<Signature>>>, check_mode: CheckMode) -> P<Signature> | checker.go:8903 | Checker
resolve_type_reference_members | pub(crate) fn resolve_type_reference_members(&mut self, t: P<Type>) | checker.go:19439 | Checker
resolve_type_reference_name | pub(crate) fn resolve_type_reference_name(&mut self, type_reference: P<Node>, meaning: SymbolFlags, ignore_errors: bool) -> P<Symbol> | checker.go:23548 | Checker
resolve_union_type_members | pub(crate) fn resolve_union_type_members(&mut self, t: P<Type>) | checker.go:21393 | Checker
resolve_untyped_call | pub(crate) fn resolve_untyped_call(&mut self, node: P<Node>) -> P<Signature> | checker.go:10094 | Checker
resolved_apparent_type | pub fn resolved_apparent_type(&self) -> Option<P<Type>> | rust:types.rs:2728 | IntersectionType
resolved_base_constraint_of | pub(crate) fn resolved_base_constraint_of(&self, t: P<Type>) -> Option<P<Type>> | rust:checker_13.rs:2536 | Checker
resolved_for_write | fn resolved_for_write(&self) -> P<StructuredMembers> | rust:types.rs:2116 | StructuredType
resolved_properties | pub fn resolved_properties(&self) -> Option<&'static [P<Symbol>]> | rust:types.rs:2588 | UnionOrIntersectionType
resolved_property_source | pub(crate) fn resolved_property_source(&self, t: P<Type>) -> Option<ResolvedPropertySource> | rust:checker_09.rs:2362 | Checker
resolved_reduced_type | pub fn resolved_reduced_type(&self) -> Option<P<Type>> | rust:types.rs:2641 | UnionType
resolved_type_of_value_symbol | fn resolved_type_of_value_symbol(&self, symbol: P<Symbol>) -> Option<P<Type>> | rust:checker_08.rs:1747 | Checker
resolved_type_predicate | pub fn resolved_type_predicate(&self, no_type_predicate: P<TypePredicate>) -> Option<P<TypePredicate>> | rust:types.rs:3038 | Signature
restore | unsafe fn restore<T: 'static>(w: Option<P<()>>) -> Option<P<T>> | rust:types.rs:388 | -
restore_bits | unsafe fn restore_bits<T: 'static>(bits: usize) -> Option<P<T>> | rust:types.rs:395 | -
restore_error_state | pub(crate) fn restore_error_state(&self, _c: &mut Checker, e: errorState) | relater.go:3219 | Relater
restore_flow_type_cache | pub(crate) fn restore_flow_type_cache(&mut self, saved: SavedFlowTypeCache) | rust:flowmemo.rs:605 | Checker
restore_height | pub(crate) fn restore_height(&mut self, saved: u16) | rust:flowmemo.rs:295 | FlowMemo
restrictive_mapper_worker | pub(crate) fn restrictive_mapper_worker(&mut self, t: P<Type>) -> P<Type> | checker.go:24995 | Checker
return_mapper | pub fn return_mapper(&self) -> Option<P<TypeMapper>> | rust:checker.rs:427 | InferenceContext
reuse_name | pub(crate) fn reuse_name(&self, c: &mut Checker, node: P<Node>, is_method: bool) -> Option<P<Node>> | nodecopy.go:24 | NodeBuilderImpl
reuse_node | pub(crate) fn reuse_node(&self, c: &mut Checker, node: P<Node>) -> Option<P<Node>> | nodecopy.go:12 | NodeBuilderImpl
reuse_type_node | pub(crate) fn reuse_type_node(&self, c: &mut Checker, node: P<Node>) -> Option<P<Node>> | nodecopy.go:56 | NodeBuilderImpl
rewrite_module_specifier | pub(crate) fn rewrite_module_specifier(&self, c: &mut Checker, parent: P<Node>, lit: P<Node>) -> P<Node> | nodecopy.go:270 | NodeBuilderImpl
run_deferred_type_argument_checks | fn run_deferred_type_argument_checks(&mut self, source_file: P<SourceFile>) | rust:checker_02.rs:1078 | Checker
run_with_inference_blocked_from_source_node | pub(crate) fn run_with_inference_blocked_from_source_node<T>(&mut self, node: P<Node>, f: impl FnOnce(&mut Checker) -> T) -> T | services.go:334 | Checker
run_without_resolved_signature_caching | pub(crate) fn run_without_resolved_signature_caching<T>(&mut self, node: P<Node>, f: impl FnOnce(&mut Checker) -> T) -> T | services.go:367 | Checker
save_height | pub(crate) fn save_height(&mut self) -> u16 | rust:flowmemo.rs:290 | FlowMemo
save_restore_flags | pub(crate) fn save_restore_flags(&self, _c: &mut Checker) -> Box<dyn FnMut(&mut Checker)> | nodebuilderimpl.go:134 | NodeBuilderImpl
serialize_constructors | pub(crate) fn serialize_constructors(&self, c: &mut Checker, static_type: P<Type>, static_base_type: Option<P<Type>>, is_class: bool, symbol: P<Symbol>) -> Vec<P<Node>> | nodebuilder_hover.go:317 | NodeBuilderImpl
serialize_flow_memo_key | pub(crate) fn serialize_flow_memo_key(&self, sink: &mut impl KeySink, f: P<FlowState>) -> bool | rust:flowmemo.rs:539 | Checker
serialize_index_signatures_of_type | pub(crate) fn serialize_index_signatures_of_type(&self, c: &mut Checker, input: P<Type>, base_type: Option<P<Type>>) -> Vec<P<Node>> | nodebuilder_hover.go:369 | NodeBuilderImpl
serialize_inferred_return_type_for_signature | pub(crate) fn serialize_inferred_return_type_for_signature(&self, c: &mut Checker, signature: P<Signature>, return_type: P<Type>) -> Option<P<Node>> | nodebuilderimpl.go:1817 | NodeBuilderImpl
serialize_namespace_member | pub(crate) fn serialize_namespace_member(&self, c: &mut Checker, resolved: P<Symbol>, name: &str) -> P<Node> | nodebuilder_hover.go:385 | NodeBuilderImpl
serialize_properties_with_truncation | pub(crate) fn serialize_properties_with_truncation(&self, c: &mut Checker, properties: &[P<Symbol>], elements: &[P<Node>]) -> Vec<P<Node>> | nodebuilder_hover.go:299 | NodeBuilderImpl
serialize_return_type_for_signature | pub fn serialize_return_type_for_signature(&self, c: &mut Checker, signature_declaration: P<Node>, enclosing_declaration: Option<P<Node>>, flags: Flags, internal_flags: InternalFlags, tracker: Option<&'static dyn SymbolTracker>) -> Option<P<Node>> | nodebuilder.go:117 | NodeBuilder
serialize_return_type_for_signature | pub(crate) fn serialize_return_type_for_signature(&self, c: &mut Checker, signature: P<Signature>, try_reuse: bool) -> Option<P<Node>> | nodebuilderimpl.go:2095 | NodeBuilderImpl
serialize_type_alias_for_namespace | pub(crate) fn serialize_type_alias_for_namespace(&self, c: &mut Checker, symbol: P<Symbol>, name: &str) -> P<Node> | nodebuilder_hover.go:558 | NodeBuilderImpl
serialize_type_for_declaration | pub fn serialize_type_for_declaration(&self, c: &mut Checker, declaration: P<Node>, symbol: Option<P<Symbol>>, enclosing_declaration: Option<P<Node>>, flags: Flags, internal_flags: InternalFlags, tracker: Option<&'static dyn SymbolTracker>) -> Option<P<Node>> | nodebuilder.go:134 | NodeBuilder
serialize_type_for_declaration | pub(crate) fn serialize_type_for_declaration(&self, c: &mut Checker, declaration: Option<P<Node>>, t: Option<P<Type>>, symbol: Option<P<Symbol>>, try_reuse: bool) -> P<Node> | nodebuilderimpl.go:2253 | NodeBuilderImpl
serialize_type_for_expression | pub fn serialize_type_for_expression(&self, c: &mut Checker, expr: P<Node>, enclosing_declaration: Option<P<Node>>, flags: Flags, internal_flags: InternalFlags, tracker: Option<&'static dyn SymbolTracker>) -> Option<P<Node>> | nodebuilder.go:140 | NodeBuilder
serialize_type_for_expression | pub(crate) fn serialize_type_for_expression(&self, c: &mut Checker, expr: P<Node>) -> Option<P<Node>> | nodebuilderimpl.go:1811 | NodeBuilderImpl
serialize_type_name | pub(crate) fn serialize_type_name(&self, c: &mut Checker, node: P<Node>, is_type_of: bool, type_arguments: Option<P<NodeList>>) -> Option<P<Node>> | nodebuilderimpl.go:442 | NodeBuilderImpl
serialize_type_parameters_for_signature | pub fn serialize_type_parameters_for_signature(&self, c: &mut Checker, signature_declaration: P<Node>, enclosing_declaration: Option<P<Node>>, flags: Flags, internal_flags: InternalFlags, tracker: Option<&'static dyn SymbolTracker>) -> Vec<P<Node>> | nodebuilder.go:126 | NodeBuilder
set | pub fn set(&self, value: usize) | rust:types.rs:21 | CountCell
set | pub fn set(&self, key: K, value: V) | rust:types.rs:112 | GoMap
set | pub fn set(&self, key: K, value: V) | rust:packedmap.rs:151 | GoPackedMap
set | pub fn set(&self, m: Option<P<TypeMapper>>) | rust:mapper.rs:418 | MapperCell
set | pub fn set(&self, f: ObjectFlags) | rust:types.rs:1254 | ObjectFlagsCell
set | pub fn set(&self, value: Option<usize>) | rust:types.rs:42 | OptionalCountCell
set | pub(crate) fn set(&self, key: RelationKey, result: RelationComparisonResult) | relater.go:106 | Relation
set_alias | pub fn set_alias(&self, alias: Option<P<TypeAlias>>) | rust:types.rs:1694 | Type
set_call_signature_count | fn set_call_signature_count(&self, count: usize) | rust:types.rs:2086 | CountOrIndexInfos
set_call_signature_count | pub fn set_call_signature_count(&self, count: usize) | rust:types.rs:2156 | StructuredType
set_comment_range | pub(crate) fn set_comment_range(&self, _c: &mut Checker, node: P<Node>, range_: Option<P<Node>>) | nodebuilderimpl.go:485 | NodeBuilderImpl
set_composite | pub fn set_composite(&self, composite: Option<P<CompositeSignature>>) | rust:types.rs:3079 | Signature
set_containing_type | pub fn set_containing_type(&self, t: Option<P<Type>>) | rust:types.rs:490 | ValueSymbolLinks
set_escaped | fn set_escaped(&self) | rust:mapper.rs:251 | TypeMapper
set_function_or_constructor_checked | pub fn set_function_or_constructor_checked(&self, v: bool) | rust:types.rs:538 | ValueSymbolLinks
set_index_infos | fn set_index_infos(&self, index_infos: &'static [P<IndexInfo>]) | rust:types.rs:2097 | CountOrIndexInfos
set_index_infos | pub fn set_index_infos(&self, index_infos: &'static [P<IndexInfo>]) | rust:types.rs:2166 | StructuredType
set_inferred_type_parameters | pub fn set_inferred_type_parameters(&self, type_parameters: &'static [P<Type>]) | rust:checker.rs:458 | InferenceContext
set_isolated_signature_type | pub fn set_isolated_signature_type(&self, t: Option<P<Type>>) | rust:types.rs:3069 | Signature
set_key_property_name | pub fn set_key_property_name(&self, name: &'static str) | rust:types.rs:2675 | UnionType
set_mapper | pub fn set_mapper(&self, mapper: Option<P<TypeMapper>>) | rust:types.rs:470 | ValueSymbolLinks
set_members | pub fn set_members(&self, members: Option<P<SymbolTable>>) | rust:types.rs:2129 | StructuredType
set_multiple_checkers | pub fn set_multiple_checkers(_multiple: bool) | rust:links.rs:394 | -
set_name_type | pub fn set_name_type(&self, t: Option<P<Type>>) | rust:types.rs:510 | ValueSymbolLinks
set_no_type_predicate | fn set_no_type_predicate(&self, on: bool) | rust:types.rs:3001 | SignatureRareWord
set_node_links_for_private_identifier_scope | pub(crate) fn set_node_links_for_private_identifier_scope(&mut self, node: P<Node>) | checker.go:10724 | Checker
set_non_fixing_mapper | pub fn set_non_fixing_mapper(&self, mapper: P<TypeMapper>) | rust:checker.rs:413 | InferenceContext
set_origin | pub fn set_origin(&self, t: Option<P<Type>>) | rust:types.rs:2665 | UnionType
set_outer_return_mapper | pub fn set_outer_return_mapper(&self, mapper: Option<P<TypeMapper>>) | rust:checker.rs:445 | InferenceContext
set_properties | pub fn set_properties(&self, properties: &'static [P<Symbol>]) | rust:types.rs:2137 | StructuredType
set_ref | pub fn set_ref(&self, m: Option<P<RefCell<FxHashMap<K, V>>>>) | rust:types.rs:160 | GoMap
set_referenced_import_declaration | pub fn set_referenced_import_declaration(&self, _c: &mut Checker, node: P<Node>, ref_: P<Node>) | emitresolver.go:869 | EmitResolver
set_regular_type | pub fn set_regular_type(&self, t: Option<P<Type>>) | rust:types.rs:2655 | UnionType
set_requires_scope_change_cache | pub(crate) fn set_requires_scope_change_cache(&mut self, node: P<Node>, value: Tristate) | checker.go:1548 | Checker
set_resolved_apparent_type | pub fn set_resolved_apparent_type(&self, t: Option<P<Type>>) | rust:types.rs:2732 | IntersectionType
set_resolved_properties | pub fn set_resolved_properties(&self, properties: Option<&'static [P<Symbol>]>) | rust:types.rs:2592 | UnionOrIntersectionType
set_resolved_reduced_type | pub fn set_resolved_reduced_type(&self, t: Option<P<Type>>) | rust:types.rs:2645 | UnionType
set_resolved_type_predicate | pub fn set_resolved_type_predicate(&self, predicate: Option<P<TypePredicate>>, no_type_predicate: P<TypePredicate>) | rust:types.rs:3046 | Signature
set_return_mapper | pub fn set_return_mapper(&self, mapper: Option<P<TypeMapper>>) | rust:checker.rs:432 | InferenceContext
set_signatures | pub fn set_signatures(&self, signatures: &'static [P<Signature>]) | rust:types.rs:2146 | StructuredType
set_sparse_id_pages | pub fn set_sparse_id_pages(_on: bool) | rust:links.rs:397 | -
set_structured_type_members | pub(crate) fn set_structured_type_members(&mut self, t: P<Type>, members: Option<P<SymbolTable>>, call_signatures: &[P<Signature>], construct_signatures: &[P<Signature>], index_infos: &[P<IndexInfo>]) | checker.go:25615 | Checker
set_symbol | pub fn set_symbol(&self, symbol: Option<P<Symbol>>) | rust:types.rs:1680 | Type
set_tail | fn set_tail(&self, tail: P<SignatureRare>) | rust:types.rs:2996 | SignatureRareWord
set_target | pub fn set_target(&self, target: Option<P<Symbol>>) | rust:types.rs:453 | ValueSymbolLinks
set_text_range | fn set_text_range(self, c: &mut Checker, range_: P<Node>, location: P<Node>) -> P<Node> | rust:nodecopy.rs:396 | ExistingNodeTree
set_text_range | pub(crate) fn set_text_range(&self, _c: &mut Checker, range_: P<Node>, location: Option<P<Node>>) -> P<Node> | nodebuilderimpl.go:1434 | NodeBuilderImpl
set_this_parameter | pub fn set_this_parameter(&self, this_parameter: Option<P<Symbol>>) | rust:types.rs:3059 | Signature
set_unique_literal_filled_instantiation | pub fn set_unique_literal_filled_instantiation(&self, t: Option<P<Type>>) | rust:types.rs:2742 | IntersectionType
set_write_type | pub fn set_write_type(&self, t: Option<P<Type>>) | rust:types.rs:528 | ValueSymbolLinks
settled_unaffected | fn settled_unaffected(&mut self, symbol: P<Symbol>, mapper: P<TypeMapper>) -> Option<bool> | rust:checker_09.rs:3048 | Checker
shadow_hit | pub(crate) fn shadow_hit(&self, flow: P<FlowNode>, key: u128, hit: MemoHit) -> ShadowHit | rust:flowmemo.rs:347 | FlowMemo
should_check_as_excess_property | pub(crate) fn should_check_as_excess_property(prop: P<Symbol>, container: Option<P<Symbol>>) -> bool | relater.go:2855 | -
should_check_erasable_syntax | pub(crate) fn should_check_erasable_syntax(&self, node: P<Node>) -> bool | checker.go:2693 | Checker
should_defer_index_type | pub(crate) fn should_defer_index_type(&mut self, t: P<Type>, index_flags: IndexFlags) -> bool | checker.go:27304 | Checker
should_defer_indexed_access_type | pub(crate) fn should_defer_indexed_access_type(&mut self, object_type: P<Type>, index_type: P<Type>, access_node: Option<P<Node>>) -> bool | checker.go:27840 | Checker
should_emit_type_of_symbol | pub(crate) fn should_emit_type_of_symbol(&self, c: &mut Checker, force_expansion: bool, force_class_expansion: bool, is_instance_type: SymbolFlags, symbol: P<Symbol>, type_id: TypeId) -> (bool, Option<P<Symbol>>) | nodebuilderimpl.go:2894 | NodeBuilderImpl
should_expand_type | pub(crate) fn should_expand_type(&self, c: &mut Checker, t: P<Type>, is_alias: bool) -> bool | nodebuilderimpl.go:212 | NodeBuilderImpl
should_mark_identifier_alias_referenced | pub(crate) fn should_mark_identifier_alias_referenced(node: P<Node>) -> bool | checker.go:28841 | -
should_normalize_intersection | pub(crate) fn should_normalize_intersection(&mut self, t: P<Type>) -> bool | checker.go:28530 | Checker
should_normalize_intersection_worker | fn should_normalize_intersection_worker(&mut self, t: P<Type>) -> bool | rust:checker_14.rs:300 | Checker
should_report_errors_from_widening_with_contextual_signature | pub(crate) fn should_report_errors_from_widening_with_contextual_signature(&mut self, declaration: P<Node>, widening_kind: WideningKind) -> bool | checker.go:20804 | Checker
should_report_unmatched_property_error | pub(crate) fn should_report_unmatched_property_error(&mut self, source: P<Type>, target: P<Type>) -> bool | relater.go:952 | Checker
should_treat_properties_of_external_module_as_exports | pub(crate) fn should_treat_properties_of_external_module_as_exports(&self, resolved_external_module_type: P<Type>) -> bool | services.go:319 | Checker
should_use_placeholder_for_property | pub(crate) fn should_use_placeholder_for_property(&self, c: &Checker, property_symbol: P<Symbol>) -> bool | nodebuilderimpl.go:2374 | NodeBuilderImpl
should_write_type_of_function_symbol | pub(crate) fn should_write_type_of_function_symbol(&self, c: &mut Checker, symbol: P<Symbol>, type_id: TypeId) -> (bool, Option<P<Symbol>>) | nodebuilderimpl.go:2852 | NodeBuilderImpl
should_write_type_parameters_in_qualified_name | pub(crate) fn should_write_type_parameters_in_qualified_name(&self, _c: &mut Checker, chain: &[P<Symbol>], index: usize) -> bool | nodebuilderimpl.go:3716 | NodeBuilderImpl
signature_has_literal_types | pub(crate) fn signature_has_literal_types(s: P<Signature>) -> bool | checker.go:9195 | -
signature_has_rest_parameter | pub(crate) fn signature_has_rest_parameter(sig: P<Signature>) -> bool | checker.go:17362 | -
signature_related_to | pub(crate) fn signature_related_to(&self, c: &mut Checker, source: P<Signature>, target: P<Signature>, erase: bool, report_errors: bool, intersection_state: IntersectionState) -> Ternary | relater.go:4575 | Relater
signature_to_signature_declaration | pub fn signature_to_signature_declaration(&mut self, signature: P<Signature>, kind: Kind, enclosing_declaration: Option<P<Node>>, flags: Flags) -> Option<P<Node>> | printer.go:293 | Checker
signature_to_signature_declaration | pub fn signature_to_signature_declaration(&self, c: &mut Checker, signature: P<Signature>, kind: Kind, enclosing_declaration: Option<P<Node>>, flags: Flags, internal_flags: InternalFlags, tracker: Option<&'static dyn SymbolTracker>) -> Option<P<Node>> | nodebuilder.go:146 | NodeBuilder
signature_to_signature_declaration_helper | pub(crate) fn signature_to_signature_declaration_helper(&self, c: &mut Checker, signature: P<Signature>, kind: Kind, options: Option<P<SignatureToSignatureDeclarationOptions>>) -> P<Node> | nodebuilderimpl.go:1864 | NodeBuilderImpl
signature_to_string | pub(crate) fn signature_to_string(&mut self, signature: P<Signature>) -> String | printer.go:179 | Checker
signature_to_string_ex | pub fn signature_to_string_ex(&mut self, signature: P<Signature>, enclosing_declaration: Option<P<Node>>, flags: TypeFormatFlags, vc: Option<P<VerbosityContext>>) -> String | printer.go:187 | Checker
signature_to_string_ex_exported | pub fn signature_to_string_ex_exported(&mut self, signature: P<Signature>, enclosing_declaration: Option<P<Node>>, flags: TypeFormatFlags, vc: Option<P<VerbosityContext>>) -> String | printer.go:183 | Checker
signatures | pub fn signatures(&self) -> &'static [P<Signature>] | rust:types.rs:2142 | StructuredType
signatures_identical_to | pub(crate) fn signatures_identical_to(&self, c: &mut Checker, source: P<Type>, target: P<Type>, kind: SignatureKind) -> Ternary | relater.go:4593 | Relater
signatures_of_structured_type | pub(crate) fn signatures_of_structured_type(&mut self, t: P<Type>, kind: SignatureKind) -> &'static [P<Signature>] | rust:checker_09.rs:2484 | Checker
signatures_of_unresolved_structured_type | fn signatures_of_unresolved_structured_type(&mut self, t: P<Type>, kind: SignatureKind) -> &'static [P<Signature>] | rust:checker_09.rs:2497 | Checker
signatures_related_to | pub(crate) fn signatures_related_to(&self, c: &mut Checker, source: P<Type>, target: P<Type>, kind: SignatureKind, report_errors: bool, intersection_state: IntersectionState) -> Ternary | relater.go:4473 | Relater
simplify_class_declaration | pub(crate) fn simplify_class_declaration(f: &NodeFactory, class_decl: P<Node>, symbol: P<Symbol>) -> P<Node> | nodebuilder.go:188 | -
simplify_modifiers | pub(crate) fn simplify_modifiers(f: &NodeFactory, new_decl: P<Node>, is_decl_kind: impl FnMut(P<Node>) -> bool, symbol: P<Symbol>) -> P<Node> | nodebuilder.go:212 | -
size | pub(crate) fn size(&self) -> usize | relater.go:113 | Relation
skip_alias | pub fn skip_alias(symbol: P<Symbol>, checker: &mut Checker) -> P<Symbol> | utilities.go:1700 | -
skip_alias | pub fn skip_alias(&mut self, symbol: P<Symbol>) -> P<Symbol> | services.go:396 | Checker
skipped_generic_function | pub(crate) fn skipped_generic_function(&self, node: P<Node>, check_mode: CheckMode) | checker.go:10217 | Checker
slice_tuple_type | pub(crate) fn slice_tuple_type(&mut self, t: P<Type>, index: usize, end_skip_count: usize) -> P<Type> | relater.go:1915 | Checker
slot | fn slot(&self, id: u64) -> Option<u32> | rust:links.rs:420 | IdLinkStore
slot_index | fn slot_index(&self, flow: P<FlowNode>, key: u128) -> usize | rust:flowmemo.rs:313 | FlowMemo
slow_threshold_ns | pub fn slow_threshold_ns() -> u64 | rust:workcensus.rs:25 | -
some_property_reduces_to_never | pub(crate) fn some_property_reduces_to_never(&mut self, t: P<Type>) -> bool | checker.go:22220 | Checker
some_signature | pub(crate) fn some_signature(signatures: &[P<Signature>], f: impl FnMut(P<Signature>) -> bool) -> bool | checker.go:8894 | -
some_symbol_table_in_scope | pub(crate) fn some_symbol_table_in_scope(&mut self, enclosing_declaration: Option<P<Node>>, callback: impl FnMut(&mut Checker, Option<P<SymbolTable>>, symbolTableID, bool, bool, Option<P<Node>>) -> bool) -> bool | symbolaccessibility.go:746 | Checker
some_type | pub(crate) fn some_type(c: &mut Checker, t: P<Type>, f: impl FnMut(&mut Checker, P<Type>) -> bool) -> bool | checker.go:27007 | -
some_type_related_to_type | pub(crate) fn some_type_related_to_type(&self, c: &mut Checker, source: P<Type>, target: P<Type>, report_errors: bool, intersection_state: IntersectionState) -> Ternary | relater.go:2951 | Relater
sort_by_best_name | pub(crate) fn sort_by_best_name(c: &mut Checker, a: &sortedSymbolNamePair, b: &sortedSymbolNamePair) -> std::cmp::Ordering | nodebuilderimpl.go:1153 | NodeBuilderImpl
sort_symbols | pub(crate) fn sort_symbols(&mut self, symbols: &mut [P<Symbol>]) | utilities.go:361 | Checker
sort_symbols_by_key | fn sort_symbols_by_key(&mut self, symbols: &mut [P<Symbol>]) -> bool | rust:utilities.rs:447 | Checker
source_file_and_index_of_node | fn source_file_and_index_of_node(&mut self, n: P<Node>) -> (tsrs_core::ptr::PKey, usize) | rust:utilities.rs:545 | Checker
source_now | pub(crate) fn source_now(&self) -> u32 | rust:flowmemo.rs:213 | FlowMemo
spill | pub(crate) fn spill(&mut self) | checker.go:17722 | keyBuilder
start_recovery_scope | pub(crate) fn start_recovery_scope(&self) -> originalRecoveryScopeState | nodecopy.go:122 | recoveryBoundary
starts_with_single_or_double_quote | pub(crate) fn starts_with_single_or_double_quote(str: &str) -> bool | nodebuilderimpl.go:924 | -
starts_with_square_bracket | pub(crate) fn starts_with_square_bracket(str: &str) -> bool | nodebuilderimpl.go:928 | -
stats_from_env | fn stats_from_env() -> bool | rust:flowmemo.rs:60 | -
stats_on | fn stats_on() -> bool | rust:infermemo.rs:83 | -
stats_on | fn stats_on() -> bool | rust:unioncache.rs:81 | -
store | pub(crate) fn store(&mut self, flow: P<FlowNode>, key: u128, t: P<Type>, height: u16, epoch: u32, count_reset: bool) | rust:flowmemo.rs:330 | FlowMemo
string_args | fn string_args(args: &[String]) -> Vec<&dyn Display> | rust:relater_1.rs:24 | -
structured_type_related_to | pub(crate) fn structured_type_related_to(&self, c: &mut Checker, source: P<Type>, target: P<Type>, report_errors: bool, intersection_state: IntersectionState) -> Ternary | relater.go:3224 | Relater
structured_type_related_to_body | fn structured_type_related_to_body(&self, c: &mut Checker, source: P<Type>, target: P<Type>, report_errors: bool, intersection_state: IntersectionState) -> Ternary | rust:relater_2.rs:992 | Relater
structured_type_related_to_worker | pub(crate) fn structured_type_related_to_worker(&self, c: &mut Checker, source: P<Type>, target: P<Type>, report_errors: bool, intersection_state: IntersectionState) -> Ternary | relater.go:3293 | Relater
subst_constraint | pub fn subst_constraint(&self) -> Option<P<Type>> | rust:types.rs:2869 | SubstitutionType
substitute_indexed_mapped_type | pub(crate) fn substitute_indexed_mapped_type(&mut self, object_type: P<Type>, index: P<Type>) -> P<Type> | checker.go:29780 | Checker
summarize_module_exports | fn summarize_module_exports(&mut self, i: u32, sym: P<Symbol>) -> bool | rust:printer.rs:893 | Checker
super_call_is_root_level_in_constructor | pub(crate) fn super_call_is_root_level_in_constructor(super_call: P<Node>, body: P<Node>) -> bool | checker.go:2956 | -
symbol | pub fn symbol(&self) -> Option<P<Symbol>> | rust:types.rs:1675 | Type
symbol | pub fn symbol(&self) -> Option<P<Symbol>> | rust:types.rs:1105 | TypeAlias
symbol | fn symbol(self) -> Option<P<Symbol>> | rust:types.rs:1291 | TypeSymbolWord
symbol_has_non_method_declaration | pub(crate) fn symbol_has_non_method_declaration(&mut self, symbol: P<Symbol>) -> bool | checker.go:12103 | Checker
symbol_is_value | pub(crate) fn symbol_is_value(&mut self, symbol: P<Symbol>) -> bool | checker.go:22487 | Checker
symbol_is_value_ex | pub(crate) fn symbol_is_value_ex(&mut self, symbol: P<Symbol>, include_type_only_members: bool) -> bool | checker.go:22491 | Checker
symbol_label | fn symbol_label(s: P<Symbol>) -> String | rust:workcensus.rs:407 | -
symbol_referenced | pub(crate) fn symbol_referenced(&mut self, symbol: P<Symbol>, meaning: SymbolFlags) | checker.go:1540 | Checker
symbol_table_id_from_exports | pub(crate) fn symbol_table_id_from_exports(sym: P<Symbol>) -> symbolTableID | symbolaccessibility.go:421 | -
symbol_table_id_from_globals | pub(crate) fn symbol_table_id_from_globals() -> symbolTableID | symbolaccessibility.go:437 | -
symbol_table_id_from_locals | pub(crate) fn symbol_table_id_from_locals(node: P<Node>) -> symbolTableID | symbolaccessibility.go:417 | -
symbol_table_id_from_members | pub(crate) fn symbol_table_id_from_members(sym: P<Symbol>) -> symbolTableID | symbolaccessibility.go:433 | -
symbol_table_id_from_resolved_exports | pub(crate) fn symbol_table_id_from_resolved_exports(sym: P<Symbol>) -> symbolTableID | symbolaccessibility.go:429 | -
symbol_to_entity_name | pub fn symbol_to_entity_name(&self, c: &mut Checker, symbol: P<Symbol>, meaning: SymbolFlags, enclosing_declaration: Option<P<Node>>, flags: Flags, internal_flags: InternalFlags, tracker: Option<&'static dyn SymbolTracker>) -> Option<P<Node>> | nodebuilder.go:225 | NodeBuilder
symbol_to_entity_name_node | pub(crate) fn symbol_to_entity_name_node(&self, c: &mut Checker, symbol: P<Symbol>) -> P<Node> | nodebuilderimpl.go:642 | NodeBuilderImpl
symbol_to_expression | pub fn symbol_to_expression(&self, c: &mut Checker, symbol: P<Symbol>, meaning: SymbolFlags, enclosing_declaration: Option<P<Node>>, flags: Flags, internal_flags: InternalFlags, tracker: Option<&'static dyn SymbolTracker>) -> Option<P<Node>> | nodebuilder.go:231 | NodeBuilder
symbol_to_expression | pub(crate) fn symbol_to_expression(&self, c: &mut Checker, symbol: P<Symbol>, mask: SymbolFlags) -> P<Node> | nodebuilderimpl.go:848 | NodeBuilderImpl
symbol_to_expression_worker | pub(crate) fn symbol_to_expression_worker(&self, c: &mut Checker, symbol: P<Symbol>, mask: SymbolFlags) -> P<Node> | nodebuilderimpl.go:853 | NodeBuilderImpl
symbol_to_name | pub(crate) fn symbol_to_name(&self, c: &mut Checker, symbol: P<Symbol>, meaning: SymbolFlags, expects_identifier: bool) -> P<Node> | nodebuilderimpl.go:606 | NodeBuilderImpl
symbol_to_node | pub fn symbol_to_node(&self, c: &mut Checker, symbol: P<Symbol>, meaning: SymbolFlags, enclosing_declaration: Option<P<Node>>, flags: Flags, internal_flags: InternalFlags, tracker: Option<&'static dyn SymbolTracker>) -> Option<P<Node>> | nodebuilder.go:237 | NodeBuilder
symbol_to_node | pub(crate) fn symbol_to_node(&self, c: &mut Checker, symbol: P<Symbol>, meaning: SymbolFlags) -> P<Node> | nodebuilderimpl.go:584 | NodeBuilderImpl
symbol_to_parameter_declaration | pub fn symbol_to_parameter_declaration(&self, c: &mut Checker, symbol: P<Symbol>, enclosing_declaration: Option<P<Node>>, flags: Flags, internal_flags: InternalFlags, tracker: Option<&'static dyn SymbolTracker>) -> Option<P<Node>> | nodebuilder.go:243 | NodeBuilder
symbol_to_parameter_declaration | pub(crate) fn symbol_to_parameter_declaration(&self, c: &mut Checker, parameter_symbol: P<Symbol>, preserve_modifier_flags: bool) -> P<Node> | nodebuilderimpl.go:1726 | NodeBuilderImpl
symbol_to_string | pub(crate) fn symbol_to_string(&mut self, symbol: P<Symbol>) -> String | printer.go:124 | Checker
symbol_to_string_ex | pub fn symbol_to_string_ex(&mut self, symbol: P<Symbol>, enclosing_declaration: Option<P<Node>>, meaning: SymbolFlags, flags: SymbolFormatFlags) -> String | printer.go:132 | Checker
symbol_to_string_ex_exported | pub fn symbol_to_string_ex_exported(&mut self, symbol: P<Symbol>, enclosing_declaration: Option<P<Node>>, meaning: SymbolFlags, flags: SymbolFormatFlags) -> String | printer.go:128 | Checker
symbol_to_string_exported | pub fn symbol_to_string_exported(&mut self, s: P<Symbol>) -> String | printer.go:120 | Checker
symbol_to_type_node | pub(crate) fn symbol_to_type_node(&self, c: &mut Checker, symbol: P<Symbol>, mask: SymbolFlags, type_arguments: Option<P<NodeList>>) -> Option<P<Node>> | nodebuilderimpl.go:650 | NodeBuilderImpl
symbol_to_type_parameter_declarations | pub fn symbol_to_type_parameter_declarations(&self, c: &mut Checker, symbol: P<Symbol>, enclosing_declaration: Option<P<Node>>, flags: Flags, internal_flags: InternalFlags, tracker: Option<&'static dyn SymbolTracker>) -> Vec<P<Node>> | nodebuilder.go:249 | NodeBuilder
symbol_to_type_parameter_declarations | pub(crate) fn symbol_to_type_parameter_declarations(&self, c: &mut Checker, symbol: P<Symbol>) -> Vec<P<Node>> | nodebuilderimpl.go:1692 | NodeBuilderImpl
symbol_value_declaration_is_context_sensitive | pub(crate) fn symbol_value_declaration_is_context_sensitive(&mut self, symbol: Option<P<Symbol>>) -> bool | relater.go:1294 | Checker
symbol_word | fn symbol_word(symbol: Option<P<Symbol>>) -> TypeSymbolWord | rust:types.rs:1280 | TypeSymbolWord
symbols_to_array | pub(crate) fn symbols_to_array(symbols: Option<P<SymbolTable>>) -> Vec<P<Symbol>> | utilities.go:1690 | -
synthetic_expression_type | pub(crate) fn synthetic_expression_type(node: P<Node>) -> P<Type> | rust:checker_15.rs:123 | -
table_bits | fn table_bits() -> u32 | rust:flowmemo.rs:66 | -
tagged | fn tagged<T>(p: P<T>, tag: usize) -> usize | rust:mapper.rs:165 | -
tagged | fn tagged<T>(p: P<T>, tag: u64) -> u64 | rust:mapper.rs:201 | -
tail | fn tail(&self) -> Option<&'static IndexInfosTail> | rust:types.rs:2073 | CountOrIndexInfos
tail | fn tail(&self) -> Option<P<SignatureRare>> | rust:types.rs:2986 | SignatureRareWord
tail | fn tail(&self) -> P<ValueSymbolLinksTail> | rust:types.rs:411 | ValueSymbolLinks
tail_for_write | fn tail_for_write(&self) -> P<ValueSymbolLinksTail> | rust:types.rs:419 | ValueSymbolLinks
taint | pub(crate) fn taint(&mut self, source: u32) | rust:flowmemo.rs:300 | FlowMemo
taint_reference | pub(crate) fn taint_reference(&mut self, source: u32) | rust:flowmemo.rs:307 | FlowMemo
take_flow_type_cache | pub(crate) fn take_flow_type_cache(&mut self) -> SavedFlowTypeCache | rust:flowmemo.rs:599 | Checker
target | pub fn target(&self) -> Option<P<Type>> | rust:types.rs:2795 | IndexType
target | pub fn target(&self) -> Option<P<Signature>> | rust:types.rs:3025 | Signature
target | pub fn target(&self) -> Option<P<Type>> | rust:types.rs:2850 | StringMappingType
target | pub fn target(&self) -> Option<P<Type>> | rust:types.rs:1614 | Type
target | pub fn target(&self) -> Option<P<Symbol>> | rust:types.rs:444 | ValueSymbolLinks
target_interface_type | pub fn target_interface_type(&self) -> &'static InterfaceType | rust:types.rs:1665 | Type
target_tuple_type | pub fn target_tuple_type(&self) -> &'static TupleType | rust:types.rs:1670 | Type
targets | fn targets(&self) -> impl Iterator<Item = P<Symbol>> + '_ | rust:printer.rs:1690 | ExportsByTarget
template_literal_types_definitely_unrelated | pub(crate) fn template_literal_types_definitely_unrelated(source: &'static TemplateLiteralType, target: &'static TemplateLiteralType) -> bool | relater.go:2354 | Checker
template_type | pub fn template_type(&self) -> Option<P<Type>> | rust:types.rs:2462 | MappedType
texts | pub fn texts(&self) -> &'static [&'static str] | rust:types.rs:2832 | TemplateLiteralType
this_parameter | pub fn this_parameter(&self) -> Option<P<Symbol>> | rust:types.rs:3055 | Signature
this_type | pub fn this_type(&self) -> Option<P<Type>> | rust:types.rs:2351 | InterfaceType
to_node_builder_flags | pub(crate) fn to_node_builder_flags(flags: TypeFormatFlags) -> Flags | printer.go:51 | -
to_type_reference_node | pub fn to_type_reference_node(&self, c: &mut Checker, b: P<NodeBuilderImpl>) -> P<Node> | nodebuilderimpl.go:3639 | TypeAlias
to_vec | pub fn to_vec(&self) -> Vec<T> | rust:checker.rs:583 | LazyVec
too_complex_key | pub(crate) fn too_complex_key<K: std::hash::Hash + ?Sized>(key: &K) -> u64 | rust:checker_13.rs:1476 | Checker
too_complex_since | pub(crate) fn too_complex_since(&self, before: u32) -> bool | rust:checker_13.rs:1502 | Checker
total | fn total(counter: &AtomicU64) -> u64 | rust:infermemo.rs:152 | -
total | fn total(counter: &AtomicU64) -> u64 | rust:unioncache.rs:168 | -
trace_unions_or_intersections_too_large | pub(crate) fn trace_unions_or_intersections_too_large(&self, _c: &mut Checker, _source: P<Type>, _target: P<Type>) | relater.go:5030 | Relater
track_computed_name | pub(crate) fn track_computed_name(&self, c: &mut Checker, access_expression: P<Node>, enclosing_declaration: Option<P<Node>>) | nodebuilderimpl.go:2433 | NodeBuilderImpl
track_existing_entity_name | fn track_existing_entity_name(self, c: &mut Checker, node: P<Node>, override_enclosing: Option<P<Node>>) -> (bool, P<Node>, Option<P<Symbol>>) | rust:nodecopy.rs:435 | ExistingNodeTree
track_symbol | pub fn track_symbol(&self, c: &mut Checker, symbol: P<Symbol>, enclosing_declaration: Option<P<Node>>, meaning: SymbolFlags) -> bool | symboltracker.go:28 | SymbolTrackerImpl
track_symbol | pub fn track_symbol(&self, _c: &mut Checker, symbol: P<Symbol>, enclosing_declaration: Option<P<Node>>, meaning: SymbolFlags) -> bool | nodecopy.go:183 | wrappingTracker
tracker | fn tracker(self) -> &'static dyn SymbolTracker | rust:nodecopy.rs:400 | ExistingNodeTree
tracker | pub(crate) fn tracker(&self) -> &'static dyn SymbolTracker | rust:nodebuilderimpl_1.rs:53 | NodeBuilderImpl
transform_type_of_members | pub(crate) fn transform_type_of_members(&mut self, t: P<Type>, f: impl FnMut(&mut Checker, P<Type>) -> P<Type>) -> P<SymbolTable> | checker.go:28646 | Checker
try_as_constrained_type | pub fn try_as_constrained_type(&self) -> Option<&'static ConstrainedType> | rust:types.rs:1587 | Type
try_as_interface_type | pub fn try_as_interface_type(&self) -> Option<&'static InterfaceType> | rust:types.rs:1603 | Type
try_as_object_type | pub fn try_as_object_type(&self) -> Option<&'static ObjectType> | rust:types.rs:1595 | Type
try_as_structured_type | pub fn try_as_structured_type(&self) -> Option<&'static StructuredType> | rust:types.rs:1591 | Type
try_as_type_reference | pub fn try_as_type_reference(&self) -> Option<&'static TypeReference> | rust:types.rs:1599 | Type
try_as_union_or_intersection_type | pub fn try_as_union_or_intersection_type(&self) -> Option<&'static UnionOrIntersectionType> | rust:types.rs:1607 | Type
try_create_awaited_type | pub(crate) fn try_create_awaited_type(&mut self, t: P<Type>) -> Option<P<Type>> | checker.go:31916 | Checker
try_create_type_reference | pub(crate) fn try_create_type_reference(&mut self, target: P<Type>, type_arguments: &[P<Type>]) -> P<Type> | checker.go:25566 | Checker
try_elaborate_array_like_errors | pub(crate) fn try_elaborate_array_like_errors(&self, c: &mut Checker, source: P<Type>, target: P<Type>, report_errors: bool) -> bool | relater.go:4411 | Relater
try_elaborate_errors_for_primitives_and_objects | pub(crate) fn try_elaborate_errors_for_primitives_and_objects(&self, c: &mut Checker, source: P<Type>, target: P<Type>) | relater.go:4440 | Relater
try_find_ambient_module | pub(crate) fn try_find_ambient_module(&mut self, module_name: &str, with_augmentations: bool) -> Option<P<Symbol>> | checker.go:15847 | Checker
try_find_ambient_module_exported | pub fn try_find_ambient_module_exported(&mut self, module_name: &str) -> Option<P<Symbol>> | exports.go:107 | Checker
try_get | pub fn try_get(&self, id: u64) -> Option<P<V>> | rust:links.rs:456 | IdLinkStore
try_get | pub fn try_get(&self, id: u64) -> Option<&'static V> | rust:links.rs:586 | InlineIdStore
try_get | pub fn try_get(&self, key: P<K>) -> Option<P<V>> | rust:links.rs:225 | KeyedLinkStore
try_get | pub fn try_get(&self, key: P<K>) -> Option<P<V>> | rust:links.rs:85 | LinkStore
try_get | pub fn try_get(&self, node: P<Node>) -> Option<&'static V> | rust:links.rs:712 | NodeLinkStore
try_get | pub fn try_get(&self, symbol: P<Symbol>) -> Option<P<V>> | rust:links.rs:760 | SymbolArenaLinkStore
try_get_declared_type_of_symbol | pub(crate) fn try_get_declared_type_of_symbol(&mut self, symbol: P<Symbol>) -> Option<P<Type>> | checker.go:24139 | Checker
try_get_element_access_expression_name | pub(crate) fn try_get_element_access_expression_name(&mut self, node: P<Node>) -> (String, bool) | flow.go:1743 | Checker
try_get_if_id_assigned | pub fn try_get_if_id_assigned(&self, node: P<Node>) -> Option<&'static V> | rust:links.rs:718 | NodeLinkStore
try_get_if_id_assigned | pub fn try_get_if_id_assigned(&self, symbol: P<Symbol>) -> Option<P<V>> | rust:links.rs:767 | SymbolArenaLinkStore
try_get_member_in_module_exports | pub fn try_get_member_in_module_exports(&mut self, member_name: &str, module_symbol: P<Symbol>) -> Option<P<Symbol>> | services.go:314 | Checker
try_get_member_in_module_exports_and_properties | pub fn try_get_member_in_module_exports_and_properties(&mut self, member_name: &str, module_symbol: P<Symbol>) -> Option<P<Symbol>> | services.go:296 | Checker
try_get_module_specifier_from_declaration | pub fn try_get_module_specifier_from_declaration(node: P<Node>) -> Option<P<Node>> | nodebuilderimpl.go:1193 | -
try_get_module_specifier_from_declaration_worker | pub(crate) fn try_get_module_specifier_from_declaration_worker(node: P<Node>) -> Option<P<Node>> | nodebuilderimpl.go:1201 | -
try_get_name_from_entity_name_expression | pub(crate) fn try_get_name_from_entity_name_expression(&mut self, node: P<Node>) -> (String, bool) | flow.go:1753 | Checker
try_get_name_from_type | pub(crate) fn try_get_name_from_type(t: P<Type>) -> (String, bool) | flow.go:1782 | -
try_get_name_from_type | pub(crate) fn try_get_name_from_type(t: P<Type>) -> (String, bool) | checker.go:19066 | Checker
try_get_pkey | fn try_get_pkey(&self, key: PKey) -> Option<P<V>> | rust:links.rs:230 | KeyedLinkStore
try_get_property_access_or_identifier_to_string | pub(crate) fn try_get_property_access_or_identifier_to_string(expr: P<Node>) -> String | utilities.go:1613 | -
try_get_qualified_name_as_value | pub(crate) fn try_get_qualified_name_as_value(&mut self, node: P<Node>) -> Option<P<Symbol>> | checker.go:16214 | Checker
try_get_resolved_symbol_from_type_node | pub(crate) fn try_get_resolved_symbol_from_type_node(c: &mut Checker, node: P<Node>) -> Option<P<Symbol>> | nodebuilderimpl.go:511 | NodeBuilderImpl
try_get_rest_type_of_signature | pub(crate) fn try_get_rest_type_of_signature(&mut self, signature: P<Signature>) -> Option<P<Type>> | checker.go:9827 | Checker
try_get_target | pub(crate) fn try_get_target(&mut self, symbol: P<Symbol>) -> Option<P<Symbol>> | services.go:453 | Checker
try_get_this_parameter_declaration | pub(crate) fn try_get_this_parameter_declaration(&self, c: &mut Checker, signature: P<Signature>) -> Option<P<Node>> | nodebuilderimpl.go:2072 | NodeBuilderImpl
try_get_this_type_at | pub(crate) fn try_get_this_type_at(&mut self, node: P<Node>) -> Option<P<Type>> | checker.go:12337 | Checker
try_get_this_type_at_ex | pub(crate) fn try_get_this_type_at_ex(&mut self, node: P<Node>, include_global_this: bool, container: Option<P<Node>>) -> Option<P<Type>> | checker.go:12349 | Checker
try_get_this_type_at_ex_exported | pub fn try_get_this_type_at_ex_exported(&mut self, node: P<Node>, include_global_this: bool, container: Option<P<Node>>) -> Option<P<Type>> | checker.go:12341 | Checker
try_get_type_at_position | pub(crate) fn try_get_type_at_position(&mut self, signature: P<Signature>, pos: usize) -> Option<P<Type>> | relater.go:1798 | Checker
try_get_type_from_type_node | pub(crate) fn try_get_type_from_type_node(&mut self, node: P<Node>) -> Option<P<Type>> | checker.go:23224 | Checker
try_js_type_node_to_type_node | pub fn try_js_type_node_to_type_node(&self, c: &mut Checker, emit_context: P<EmitContext>, type_node: P<Node>, enclosing_declaration: Option<P<Node>>, flags: Flags, internal_flags: InternalFlags, tracker: &'static dyn SymbolTracker) -> Option<P<Node>> | emitresolver.go:1272 | EmitResolver
try_js_type_node_to_type_node | pub fn try_js_type_node_to_type_node(&self, c: &mut Checker, node: P<Node>, enclosing_declaration: Option<P<Node>>, flags: Flags, internal_flags: InternalFlags, tracker: Option<&'static dyn SymbolTracker>) -> Option<P<Node>> | nodebuilder.go:272 | NodeBuilder
try_js_type_node_to_type_node | pub(crate) fn try_js_type_node_to_type_node(&self, c: &mut Checker, node: P<Node>) -> Option<P<Node>> | nodecopy.go:20 | NodeBuilderImpl
try_merge_union_of_object_type_and_empty_object | pub(crate) fn try_merge_union_of_object_type_and_empty_object(&mut self, t: P<Type>, readonly: bool) -> P<Type> | checker.go:13748 | Checker
try_resolve_alias | pub(crate) fn try_resolve_alias(&mut self, symbol: P<Symbol>) -> Option<P<Symbol>> | checker.go:16626 | Checker
try_resolve_pattern_ambient_module | pub(crate) fn try_resolve_pattern_ambient_module(&mut self, resolved_symbol: Option<P<Symbol>>, module_reference: &str, import_attributes_type: P<Type>) -> Option<P<Symbol>> | checker.go:15696 | Checker
try_resolved_property | pub(crate) fn try_resolved_property(&mut self, t: P<Type>, key: HashedName<'_>, skip_object_function_property_augment: bool) -> Option<Option<P<Symbol>>> | rust:checker_09.rs:2394 | Checker
try_reuse_existing_node_helper | pub(crate) fn try_reuse_existing_node_helper(&self, c: &mut Checker, existing: P<Node>) -> Option<P<Node>> | nodecopy.go:222 | NodeBuilderImpl
try_reuse_existing_non_parameter_type_node | pub(crate) fn try_reuse_existing_non_parameter_type_node(&self, c: &mut Checker, existing: P<Node>, t: P<Type>, host: Option<P<Node>>, annotation_type: Option<P<Type>>) -> Option<P<Node>> | nodebuilderimpl.go:548 | NodeBuilderImpl
try_symbol_table | pub(crate) fn try_symbol_table(&mut self, ctx: &accessibleSymbolChainContext, symbols: Option<P<SymbolTable>>, table_id: symbolTableID, ignore_qualification: bool, is_local_name_lookup: bool) -> Vec<P<Symbol>> | symbolaccessibility.go:535 | Checker
try_visit_indexed_access | fn try_visit_indexed_access(self, c: &mut Checker, v: &mut NodeVisitor, node: P<Node>) -> Option<P<Node>> | rust:nodecopy.rs:522 | ExistingNodeTree
try_visit_key_of | fn try_visit_key_of(self, c: &mut Checker, v: &mut NodeVisitor, node: P<Node>) -> Option<P<Node>> | rust:nodecopy.rs:529 | ExistingNodeTree
try_visit_simple_type_node | fn try_visit_simple_type_node(self, c: &mut Checker, v: &mut NodeVisitor, node: P<Node>) -> Option<P<Node>> | rust:nodecopy.rs:590 | ExistingNodeTree
try_visit_type_query | fn try_visit_type_query(self, c: &mut Checker, v: &mut NodeVisitor, node: P<Node>) -> Option<P<Node>> | rust:nodecopy.rs:536 | ExistingNodeTree
try_visit_type_reference | fn try_visit_type_reference(self, c: &mut Checker, v: &mut NodeVisitor, node: P<Node>) -> Option<P<Node>> | rust:nodecopy.rs:553 | ExistingNodeTree
tuple_element_flags | pub fn tuple_element_flags(self) -> ElementFlags | rust:types.rs:2381 | TupleElementInfo
tuple_types_definitely_unrelated | pub(crate) fn tuple_types_definitely_unrelated(source: P<Type>, target: P<Type>) -> bool | inference.go:1195 | -
type_ | pub fn type_(&self) -> Option<P<Type>> | rust:types.rs:3124 | TypePredicate
type_arguments | pub fn type_arguments(&self) -> &'static [P<Type>] | rust:types.rs:1109 | TypeAlias
type_arguments_related_to | pub(crate) fn type_arguments_related_to(&self, c: &mut Checker, sources: &[P<Type>], targets: &[P<Type>], variances: &[VarianceFlags], report_errors: bool, intersection_state: IntersectionState) -> Ternary | relater.go:3935 | Relater
type_comparer | pub fn type_comparer(f: impl Fn(&mut Checker, P<Type>, P<Type>, bool) -> Ternary + 'static) -> TypeComparer | rust:types.rs:3219 | -
type_could_have_top_level_singleton_types | pub(crate) fn type_could_have_top_level_singleton_types(&mut self, t: P<Type>) -> bool | relater.go:1298 | Checker
type_elements_to_class_elements | pub(crate) fn type_elements_to_class_elements(f: &NodeFactory, members: &mut [P<Node>]) -> Vec<P<Node>> | nodebuilder_hover.go:217 | -
type_has_call_or_construct_signatures | pub fn type_has_call_or_construct_signatures(&mut self, t: P<Type>) -> bool | checker.go:28331 | Checker
type_has_call_or_construct_signatures_exported | pub fn type_has_call_or_construct_signatures_exported(&mut self, t: P<Type>) -> bool | exports.go:147 | Checker
type_has_protected_accessible_base | pub(crate) fn type_has_protected_accessible_base(&mut self, target: P<Symbol>, t: P<Type>) -> bool | checker.go:8864 | Checker
type_has_static_property | pub(crate) fn type_has_static_property(&mut self, prop_name: &str, containing_type: P<Type>) -> bool | checker.go:27685 | Checker
type_identity | pub(crate) fn type_identity(t: P<Type>) -> (Option<P<Symbol>>, u8) | rust:workcensus.rs:349 | -
type_kind_label | pub(crate) fn type_kind_label(flags: TypeFlags, object_flags: ObjectFlags) -> &'static str | rust:checker_12.rs:2716 | -
type_maybe_assignable_to | pub(crate) fn type_maybe_assignable_to(&mut self, source: P<Type>, target: P<Type>) -> bool | flow.go:2434 | Checker
type_node_is_equivalent_to_type | pub(crate) fn type_node_is_equivalent_to_type(c: &mut Checker, annotated_declaration: Option<P<Node>>, t: P<Type>, type_from_type_node: P<Type>) -> bool | nodebuilderimpl.go:492 | NodeBuilderImpl
type_parameter | pub fn type_parameter(&self) -> Option<P<Type>> | rust:types.rs:2450 | MappedType
type_parameter_contains_reference | pub(crate) fn type_parameter_contains_reference(&mut self, tp: P<Type>, node: P<Node>) -> bool | rust:checker_11.rs:1490 | Checker
type_parameter_shadows_other_type_parameter_in_scope | pub(crate) fn type_parameter_shadows_other_type_parameter_in_scope(&self, c: &mut Checker, name: &str, type_parameter: P<Type>) -> bool | nodebuilderimpl.go:1468 | NodeBuilderImpl
type_parameter_to_declaration | pub fn type_parameter_to_declaration(&self, c: &mut Checker, parameter: P<Type>, enclosing_declaration: Option<P<Node>>, flags: Flags, internal_flags: InternalFlags, tracker: Option<&'static dyn SymbolTracker>) -> Option<P<Node>> | nodebuilder.go:255 | NodeBuilder
type_parameter_to_declaration | pub(crate) fn type_parameter_to_declaration(&self, c: &mut Checker, parameter: P<Type>) -> P<Node> | nodebuilderimpl.go:1683 | NodeBuilderImpl
type_parameter_to_declaration_with_constraint | pub(crate) fn type_parameter_to_declaration_with_constraint(&self, c: &mut Checker, type_parameter: P<Type>, constraint_node: Option<P<Node>>) -> P<Node> | nodebuilderimpl.go:1401 | NodeBuilderImpl
type_parameter_to_name | pub(crate) fn type_parameter_to_name(&self, c: &mut Checker, type_parameter: P<Type>) -> P<Node> | nodebuilderimpl.go:1476 | NodeBuilderImpl
type_parameter_to_string_ex | pub fn type_parameter_to_string_ex(&mut self, t: P<Type>, enclosing_declaration: Option<P<Node>>, vc: Option<P<VerbosityContext>>) -> String | printer.go:328 | Checker
type_parameters | pub fn type_parameters(&self) -> &'static [P<Type>] | rust:types.rs:2342 | InterfaceType
type_parameters | pub fn type_parameters(&self) -> &'static [P<Type>] | rust:types.rs:3017 | Signature
type_parameters_to_type_parameter_declarations | pub(crate) fn type_parameters_to_type_parameter_declarations(&self, c: &mut Checker, symbol: P<Symbol>) -> Vec<P<Node>> | nodebuilderimpl.go:1696 | NodeBuilderImpl
type_predicate_kinds_match | pub(crate) fn type_predicate_kinds_match(a: P<TypePredicate>, b: P<TypePredicate>) -> bool | relater.go:2113 | Checker
type_predicate_to_string | pub(crate) fn type_predicate_to_string(&mut self, type_predicate: P<TypePredicate>) -> String | printer.go:229 | Checker
type_predicate_to_string_ex | pub(crate) fn type_predicate_to_string_ex(&mut self, type_predicate: P<TypePredicate>, enclosing_declaration: Option<P<Node>>, flags: TypeFormatFlags) -> String | printer.go:233 | Checker
type_predicate_to_string_exported | pub fn type_predicate_to_string_exported(&mut self, t: P<TypePredicate>) -> String | exports.go:251 | Checker
type_predicate_to_type_predicate_node | pub fn type_predicate_to_type_predicate_node(&mut self, t: P<TypePredicate>, enclosing_declaration: Option<P<Node>>, flags: Flags, id_to_symbol: Option<P<RefCell<FxHashMap<P<Node>, P<Symbol>>>>>) -> Option<P<Node>> | printer.go:353 | Checker
type_predicate_to_type_predicate_node | pub fn type_predicate_to_type_predicate_node(&self, c: &mut Checker, predicate: P<TypePredicate>, enclosing_declaration: Option<P<Node>>, flags: Flags, internal_flags: InternalFlags, tracker: Option<&'static dyn SymbolTracker>) -> Option<P<Node>> | nodebuilder.go:261 | NodeBuilder
type_predicate_to_type_predicate_node | pub(crate) fn type_predicate_to_type_predicate_node(&self, c: &mut Checker, predicate: P<TypePredicate>) -> P<Node> | nodebuilderimpl.go:1646 | NodeBuilderImpl
type_predicate_to_type_predicate_node_helper | pub(crate) fn type_predicate_to_type_predicate_node_helper(&self, c: &mut Checker, type_predicate: P<TypePredicate>) -> P<Node> | nodebuilderimpl.go:1837 | NodeBuilderImpl
type_reference_to_type_node | pub(crate) fn type_reference_to_type_node(&self, c: &mut Checker, t: P<Type>) -> Option<P<Node>> | nodebuilderimpl.go:3070 | NodeBuilderImpl
type_related_to_discriminated_type | pub(crate) fn type_related_to_discriminated_type(&self, c: &mut Checker, source: P<Type>, target: P<Type>) -> Ternary | relater.go:4021 | Relater
type_related_to_each_type | pub(crate) fn type_related_to_each_type(&self, c: &mut Checker, source: P<Type>, target: P<Type>, report_errors: bool, intersection_state: IntersectionState) -> Ternary | relater.go:3063 | Relater
type_related_to_index_info | pub(crate) fn type_related_to_index_info(&self, c: &mut Checker, source: P<Type>, target_info: P<IndexInfo>, report_errors: bool, intersection_state: IntersectionState) -> Ternary | relater.go:4635 | Relater
type_related_to_some_type | pub(crate) fn type_related_to_some_type(&self, c: &mut Checker, source: P<Type>, target: P<Type>, report_errors: bool, intersection_state: IntersectionState) -> Ternary | relater.go:3004 | Relater
type_related_to_some_type_worker | fn type_related_to_some_type_worker(&self, c: &mut Checker, source: P<Type>, target: P<Type>, report_errors: bool, intersection_state: IntersectionState, outcome: &mut (u8, u8, u32)) -> Ternary | rust:relater_2.rs:617 | Relater
type_resolution_has_property | pub(crate) fn type_resolution_has_property(&mut self, r: &TypeResolution) -> bool | checker.go:19140 | Checker
type_to_string | pub(crate) fn type_to_string(&mut self, t: P<Type>, enclosing_declaration: Option<P<Node>>) -> String | printer.go:47 | Checker
type_to_string_ex | pub fn type_to_string_ex(&mut self, t: P<Type>, enclosing_declaration: Option<P<Node>>, flags: TypeFormatFlags, vc: Option<P<VerbosityContext>>) -> String | printer.go:59 | Checker
type_to_string_ex_exported | pub fn type_to_string_ex_exported(&mut self, t: P<Type>, enclosing_declaration: Option<P<Node>>, flags: TypeFormatFlags, vc: Option<P<VerbosityContext>>) -> String | printer.go:55 | Checker
type_to_string_exported | pub fn type_to_string_exported(&mut self, t: P<Type>) -> String | printer.go:43 | Checker
type_to_type_node | pub fn type_to_type_node(&mut self, t: P<Type>, enclosing_declaration: Option<P<Node>>, flags: Flags, id_to_symbol: Option<P<RefCell<FxHashMap<P<Node>, P<Symbol>>>>>) -> Option<P<Node>> | printer.go:288 | Checker
type_to_type_node | pub fn type_to_type_node(&self, c: &mut Checker, typ: P<Type>, enclosing_declaration: Option<P<Node>>, flags: Flags, internal_flags: InternalFlags, tracker: Option<&'static dyn SymbolTracker>) -> Option<P<Node>> | nodebuilder.go:267 | NodeBuilder
type_to_type_node | pub(crate) fn type_to_type_node(&self, c: &mut Checker, t: Option<P<Type>>) -> Option<P<Node>> | nodebuilderimpl.go:3303 | NodeBuilderImpl
type_to_type_node_ex | pub fn type_to_type_node_ex(&mut self, t: P<Type>, enclosing_declaration: Option<P<Node>>, flags: Flags, internal_flags: InternalFlags, id_to_symbol: Option<P<RefCell<FxHashMap<P<Node>, P<Symbol>>>>>) -> Option<P<Node>> | printer.go:348 | Checker
type_to_type_node_helper_with_possible_reusable_type_node | pub(crate) fn type_to_type_node_helper_with_possible_reusable_type_node(&self, c: &mut Checker, t: Option<P<Type>>, type_node: Option<P<Node>>) -> Option<P<Node>> | nodebuilderimpl.go:1669 | NodeBuilderImpl
type_to_type_node_or_circularity_elision | pub(crate) fn type_to_type_node_or_circularity_elision(&self, c: &mut Checker, t: P<Type>) -> Option<P<Node>> | nodebuilderimpl.go:2995 | NodeBuilderImpl
types | pub fn types(&self) -> &'static [P<Type>] | rust:types.rs:2836 | TemplateLiteralType
types | pub fn types(&self) -> &'static [P<Type>] | rust:types.rs:1653 | Type
types | pub fn types(&self) -> &'static [P<Type>] | rust:types.rs:2560 | UnionOrIntersectionType
types_are_same_reference | pub(crate) fn types_are_same_reference(a: P<Type>, b: P<Type>) -> bool | nodebuilderimpl.go:481 | -
types_definitely_unrelated | pub(crate) fn types_definitely_unrelated(&mut self, source: P<Type>, target: P<Type>) -> bool | inference.go:1185 | Checker
union_cache_finish | pub fn union_cache_finish() | rust:unioncache.rs:352 | Checker
union_cache_mode | pub(crate) fn union_cache_mode() -> UnionCacheMode | rust:unioncache.rs:73 | -
union_contains_type | pub(crate) fn union_contains_type(&mut self, union: P<Type>, t: P<Type>, match_symbol: bool) -> bool | checker.go:26875 | Checker
union_object_and_array_literal_candidates | pub(crate) fn union_object_and_array_literal_candidates(&mut self, candidates: &[P<Type>]) -> Vec<P<Type>> | inference.go:1470 | Checker
union_or_intersection_related_to | pub(crate) fn union_or_intersection_related_to(&self, c: &mut Checker, source: P<Type>, target: P<Type>, report_errors: bool, intersection_state: IntersectionState) -> Ternary | relater.go:2882 | Relater
union_rare | fn union_rare(&self) -> Option<&'static UnionRare> | rust:types.rs:2629 | UnionType
union_rare_for_write | fn union_rare_for_write(&self) -> &'static UnionRare | rust:types.rs:2635 | UnionType
union_types | pub fn union_types(&self) -> Vec<P<Type>> | checker.go:26227 | Checker
unique_literal_filled_instantiation | pub fn unique_literal_filled_instantiation(&self) -> Option<P<Type>> | rust:types.rs:2738 | IntersectionType
unpack_slice | unsafe fn unpack_slice(w: usize) -> &'static [P<Type>] | rust:mapper.rs:157 | -
unpack_slice | unsafe fn unpack_slice(w: u64) -> &'static [P<Type>] | rust:mapper.rs:191 | -
untagged | unsafe fn untagged<T>(w: usize) -> P<T> | rust:mapper.rs:173 | -
untagged | unsafe fn untagged<T>(w: u64) -> P<T> | rust:mapper.rs:209 | -
unused_is_error | pub(crate) fn unused_is_error(&self, kind: UnusedKind) -> bool | checker.go:7276 | Checker
unwrap_awaited_type | pub(crate) fn unwrap_awaited_type(&mut self, t: P<Type>) -> P<Type> | checker.go:31928 | Checker
unwrap_return_type | pub(crate) fn unwrap_return_type(&mut self, return_type: P<Type>, function_flags: FunctionFlags) -> Option<P<Type>> | checker.go:20729 | Checker
value | pub fn value(&self) -> Option<LiteralValue> | rust:types.rs:1983 | LiteralType
value_equals | pub(crate) fn value_equals(&self, other: &LiteralType) -> bool | rust:types.rs:1988 | LiteralType
value_of | fn value_of(t: P<Type>) -> &'static str | rust:packedmap.rs:198 | StringLiteralTypes
value_to_string | pub fn value_to_string(value: LiteralValue) -> String | utilities.go:1749 | -
value_to_string | pub(crate) fn value_to_string(value: LiteralValue) -> String | printer.go:249 | Checker
value_type | pub fn value_type(&self) -> P<Type> | rust:types.rs:3159 | IndexInfo
values | pub fn values(&self) -> impl Iterator<Item = &V> + '_ | rust:basedmap.rs:101 | Based
values | pub fn values(&self) -> impl Iterator<Item = V> + '_ | rust:basedmap.rs:54 | Based
values | pub fn values(&self) -> impl Iterator<Item = V> + '_ | rust:packedmap.rs:115 | PackedMap
visibility_to_string | pub(crate) fn visibility_to_string(flags: ModifierFlags) -> String | relater.go:2559 | -
visit | fn visit(self, c: &mut Checker, v: &mut NodeVisitor, node: P<Node>) -> Option<P<Node>> | rust:nodecopy.rs:927 | ExistingNodeTree
visit_and_transform_type | pub(crate) fn visit_and_transform_type(&self, c: &mut Checker, t: P<Type>, transform: impl FnMut(&mut Checker, P<NodeBuilderImpl>, P<Type>) -> Option<P<Node>>) -> Option<P<Node>> | nodebuilderimpl.go:3212 | NodeBuilderImpl
visit_each_child | fn visit_each_child(self, c: &mut Checker, v: &mut NodeVisitor, node: P<Node>) -> Option<P<Node>> | rust:nodecopy.rs:391 | ExistingNodeTree
visit_existing_node_tree_symbols_worker | fn visit_existing_node_tree_symbols_worker(self, c: &mut Checker, v: &mut NodeVisitor, node: P<Node>) -> Option<P<Node>> | rust:nodecopy.rs:605 | ExistingNodeTree
visit_modifiers | fn visit_modifiers(self, c: &mut Checker, v: &mut NodeVisitor, nodes: Option<P<ModifierList>>) -> Option<P<ModifierList>> | rust:nodecopy.rs:387 | ExistingNodeTree
visit_node | fn visit_node(self, c: &mut Checker, v: &mut NodeVisitor, node: Option<P<Node>>) -> Option<P<Node>> | rust:nodecopy.rs:379 | ExistingNodeTree
visit_nodes | fn visit_nodes(self, c: &mut Checker, v: &mut NodeVisitor, nodes: Option<P<NodeList>>) -> Option<P<NodeList>> | rust:nodecopy.rs:383 | ExistingNodeTree
walk_node_for_expandability | pub(crate) fn walk_node_for_expandability(&self, c: &mut Checker, node: Option<P<Node>>) | nodecopy.go:78 | NodeBuilderImpl
walk_up_outer_expressions | pub(crate) fn walk_up_outer_expressions(node: P<Node>) -> Option<P<Node>> | utilities.go:1906 | -
was_canceled | pub fn was_canceled(&self) -> bool | exports.go:171 | Checker
wide_get | fn wide_get(&self, id: u64) -> Option<&'static V> | rust:links.rs:606 | InlineIdStore
wide_slot | fn wide_slot(&self, id: u64) -> Option<u32> | rust:links.rs:451 | IdLinkStore
widen_type_for_variable_like_declaration | pub(crate) fn widen_type_for_variable_like_declaration(&mut self, t: Option<P<Type>>, declaration: P<Node>, report_errors: bool) -> P<Type> | checker.go:18582 | Checker
widen_type_inferred_from_initializer | pub(crate) fn widen_type_inferred_from_initializer(&mut self, declaration: P<Node>, t: P<Type>) -> P<Type> | checker.go:17206 | Checker
with | pub fn with<R>(&self, f: impl FnOnce(&mut Checker) -> R) -> R | rust:nodebuilder_types.rs:232 | CheckerSlot
with_slice | pub fn with_slice<R>(&self, f: impl FnOnce(&[T]) -> R) -> R | rust:checker.rs:587 | LazyVec
worker_comparer | pub fn worker_comparer(&self) -> TypeComparer | rust:relater_types.rs:243 | Relater
write_alias | pub(crate) fn write_alias(&mut self, alias: Option<P<TypeAlias>>) | checker.go:17781 | keyBuilder
write_alias_arg | pub(crate) fn write_alias_arg(&mut self, alias: AliasArg<'_>) | rust:checker_09.rs:487 | keyBuilder
write_byte | pub(crate) fn write_byte(&mut self, c: u8) | checker.go:17727 | keyBuilder
write_flow_cache_key | pub(crate) fn write_flow_cache_key(&mut self, b: &mut keyBuilder, node: P<Node>, declared_type: P<Type>, initial_type: P<Type>, flow_container: Option<P<Node>>) -> bool | flow.go:1665 | Checker
write_flow_memo_reference | fn write_flow_memo_reference(&self, sink: &mut impl KeySink, node: P<Node>) -> bool | rust:flowmemo.rs:557 | Checker
write_generic_type_references | pub(crate) fn write_generic_type_references(&mut self, c: &mut Checker, source: P<Type>, target: P<Type>, ignore_constraints: bool) -> bool | checker.go:17791 | keyBuilder
write_node | pub(crate) fn write_node(&mut self, node: Option<P<Node>>) | checker.go:17830 | keyBuilder
write_node_id | pub(crate) fn write_node_id(&mut self, id: NodeId) | checker.go:17826 | keyBuilder
write_some_alias_arg | fn write_some_alias_arg(&mut self, alias: AliasArg<'_>) | rust:checker_09.rs:495 | keyBuilder
write_string | pub(crate) fn write_string(&mut self, s: &str) | checker.go:17735 | keyBuilder
write_symbol | pub(crate) fn write_symbol(&mut self, s: P<Symbol>) | checker.go:17766 | keyBuilder
write_type | pub fn write_type(&self) -> Option<P<Type>> | rust:types.rs:521 | ValueSymbolLinks
write_type | pub(crate) fn write_type(&mut self, t: P<Type>) | checker.go:17770 | keyBuilder
write_types | pub(crate) fn write_types(&mut self, types: &[P<Type>]) | checker.go:17774 | keyBuilder
write_uint32 | pub(crate) fn write_uint32(&mut self, v: u32) | checker.go:17746 | keyBuilder
write_uint64 | pub(crate) fn write_uint64(&mut self, v: u64) | checker.go:17754 | keyBuilder
write_usize | pub(crate) fn write_usize(&mut self, value: usize) | checker.go:17762 | keyBuilder
