package diffast-core

You can search for identifiers within the package.

in-package search v0.2.0

diffast-core
- Diffast_core
  - Adiff
  - Analyzing
    
    F
    
    Label
    
    Postprocessing
    
    mid_data
    
    tree_comparator
  - Astml
    
    Attr
  - Cache
  - Change_base
    
    F
    
    L
    
    c
    
    change_set
  - Charpool
  - Comparison
    
    c
    
    multiple_node_matches
    
    multiple_subtree_matches
    
    pairs
  - Const
  - Delta
    
    Edit
    
    seq
  - Delta_base
    
    Fmt
    
    Irr
    
    Rev
    
    edit_tbl
    
    node_tbl
    
    boundary_path
    
    path_c
  - Delta_common
  - Delta_format
    
    Format
    
    IrreversibleFormat
    
    ReversibleFormat
  - Delta_interpret
    
    interpreter
  - Delta_options
    
    c
  - Dirtree
    
    c
    
    diff_result
    
    node_data
    
    node_map
  - Dirtree_base
    
    c
    
    node_data
  - Edit
    
    formatters_base
    
    seq
    
    seq_base
  - Edit_base
    
    formatters_base
    
    seq_base
  - Editop
  - Engine_options
    
    c
  - Entity
  - Fact_base
    
    F
    
    L
    
    extractor_base
    
    fact_buffer_tbl
    
    fact_store
    
    separate_fact_buffer_tbl
    
    unified_fact_buffer_tbl
  - Fact_options
    
    c
  - Flattreediff
  - GIDfragment
    
    c
  - Info
  - Key
  - Lang
    
    c
    
    lang_t
    
    make_null_tree_patcher
    
    tree_comparator
    
    tree_patcher
  - Lang_base
    
    c
    
    lang_t
    
    tree_builder
    
    tree_factory
  - Misc
    
    Tbl1
    
    Tbl2
    
    Tbl3
    
    Tbl4
    
    counter
    
    stopwatch
  - Moveid
    
    generator
  - Node
    
    M
    
    Tbl
  - Node_mapping
    
    Json
    
    c
  - Options
    
    c
  - Parser_options
    
    c
  - Postprocessing
    
    F
    
    Label
    
    mid_data
  - Proximity
    
    node_proximity
  - Pruned
    
    nodes
  - Sites
    
    Plugins
    
    Lang_specs
    
    Langs
    
    Sites
  - Sourcecode
    
    Tree
    
    L
    
    c
    
    node_data
    
    node_maker
    
    ordinal_tbl
    
    stack
    
    visitor
  - Spec
    
    LABEL_T
    
    nmapping_t
    
    node_data_t
    
    npairs_t
    
    tree_t
  - Spec_base
    
    OutChannel
    
    node_data_t_shared
    
    tree_factory_t
    
    tree_t_shared
  - Stat
    
    Dir
    
    File
  - Treediff
  - Triple
    
    buffer
    
    buffer_base
    
    buffer_directory
    
    buffer_odbc
    
    buffer_virtuoso
    
    dumper
    
    dumper_gen

Legend:
Library
Module
Module type
Parameter
Class
Class type

constraint 'a = Diffast_core.Node_mapping.Nodetbl.key


  constraint
    'b =
    < fast_scan_whole_initial : 
      (< data : < to_be_notified : bool.. >.. > -> unit) ->
      'c
    ; fast_scan_whole_initial_subtree : 'a -> ('a -> unit) -> 'd
    ; fast_whole_initial_subtree_size : 'a -> int
    ; in_subtree_mutually : 'a -> 'a -> bool
    ; initial_ancestor_nodeposs : 'a -> ('a * int) list
    ; initial_ancestor_nodes : 'a -> 'a list
    ; initial_leftmost : 'a -> < gindex : Diffast_core.Spec.SB.Otree.GI.t.. >
    ; is_initial_ancestor : 'a -> 'a -> bool
    ; preorder_scan_whole_initial_subtree : 
      Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2 ->
      ('a -> unit) ->
      'e
    ; root : 'a
    ; scan_whole_initial : 
      (< data : < binding : B.t.. >.. > as 'f -> unit) ->
      unit
    ; search_node_by_uid : Diffast_misc.UID.t -> 'a.. >

val mutable use_adjacency_cache : bool

val mutable use_similarity_cache : bool

val mutable use_mapping_comparison_cache : bool

method _is_incompatible : 'a -> 'a -> 'a -> 'a -> bool

method is_incompatible : 'a -> 'a -> 'a -> 'a -> bool

method is_crossing_or_incompatible : 'a -> 'a -> 'a -> 'a -> bool

method select_p_pairs : ('a -> 'a -> 'a -> 'a -> bool) ->
  ('a * 'a * weight_t) list ->
  ('a * 'a * weight_t) list * ('a * 'a * weight_t) list

method select_compatible_pairs : ('a * 'a * weight_t) list ->
  ('a * 'a * weight_t) list * ('a * 'a * weight_t) list

method select_compatible_and_not_crossing_pairs : ('a * 'a * weight_t) list ->
  ('a * 'a * weight_t) list * ('a * 'a * weight_t) list

method get_boundary_key : 'a ->
  'a ->
  Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2 option
  * Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2 option

val mutable has_use_rename_opt : ('a -> 'a -> bool) option

val adjacency_cache : (('a * 'a) option, 'a, 'a, float * ('a * 'a) list)
                        Diffast_core.Misc.Tbl3.t

method set_has_use_rename : ('a -> 'a -> bool) -> unit

method _has_use_rename : 'a -> 'a -> bool

method has_use_rename : 'a -> 'a -> bool

method can_be_cached : 'a -> 'a -> bool

val mutable rename_pat_finalized_flag : bool

method finalize_rename_pat : unit -> unit

val rename_pat : (string * string) Xset.t

method add_rename_pat : (string * string) -> unit

method is_rename_pat : (string * string) -> bool

val ref_npairs : 'a pairs

method ref_npairs : 'a pairs

val permutation_hub_tbl : ('a * 'a * string,
                            int
                            * Diffast_core.Spec.SB.Otree.GI.t
                            * Diffast_core.Spec.SB.Otree.GI.t
                            * Diffast_core.Spec.SB.Otree.GI.t
                            * Diffast_core.Spec.SB.Otree.GI.t)
                            Hashtbl.t

method add_permutation_hub_cand : 'a -> 'a -> string -> unit

method finalize_permutation_hub_tbl : unit -> unit

method under_permutation_hub : 'a -> 'a -> bool

method under_permutation_hub1 : 'a -> bool

method under_permutation_hub2 : 'a -> bool

val mutable cache_path : string

val mutable is_possible_rename : ?strict:bool -> 'a -> 'a -> bool

val is_possible_rename_cache : (bool, 'a, 'a, bool) Diffast_core.Misc.Tbl3.t

method _is_possible_rename : ?strict:bool -> 'a -> 'a -> bool

method is_possible_rename : ?strict:bool -> 'a -> 'a -> bool

method set_is_possible_rename : (?strict:bool -> 'a -> 'a -> bool) -> unit

val mutable def_bid_map1_set : bool

val mutable def_bid_map2_set : bool

method def_bid_maps_set : bool

val mutable def_bid_map1 : (B.ID.t, B.ID.t) Hashtbl.t

val mutable def_bid_map2 : (B.ID.t, B.ID.t) Hashtbl.t

method set_def_bid_map1 : (B.ID.t, B.ID.t) Hashtbl.t -> unit

method set_def_bid_map2 : (B.ID.t, B.ID.t) Hashtbl.t -> unit

val mutable def_use_tbl1_set : bool

val mutable def_use_tbl2_set : bool

method def_use_tbls_set : bool

val mutable def_use_tbl1 : 'a list Nodetbl.t

val mutable def_use_tbl2 : 'a list Nodetbl.t

method set_def_use_tbl1 : 'a list Nodetbl.t -> unit

method set_def_use_tbl2 : 'a list Nodetbl.t -> unit

method has_use_mapping : 'a Diffast_core.Node_mapping.c ->
  Nodetbl.key ->
  Nodetbl.key ->
  bool

method scan_subtree_pair : 'a -> 'a -> ('a -> 'a -> unit) -> unit

method is_scope_consistent_mapping : ?local:bool ->
  'a Diffast_core.Node_mapping.c ->
  'a ->
  'a ->
  bool

method private _is_scope_breaking_mapping : 'a Diffast_core.Node_mapping.c ->
  'a ->
  'a ->
  bool

method is_scope_breaking_mapping : ?subtree:bool ->
  'a Diffast_core.Node_mapping.c ->
  'a ->
  'a ->
  bool

val bad_pairs : ('a * 'a) Xset.t

method bad_pairs : ('a * 'a) Xset.t

method add_bad_pair : 'a -> 'a -> unit

method is_bad_pair : 'a -> 'a -> bool

val subtree_matches : ('a * 'a * int) Xset.t

method subtree_matches : ('a * 'a * int) Xset.t

method in_subtree_matches : 'a -> 'a -> bool

method get_subtree_match_size : 'a -> 'a -> int

method add_subtree_match : ('a * 'a * int) -> unit

val mutable multiple_subtree_matches : 'a multiple_subtree_matches option

method set_multiple_subtree_matches : 'a multiple_subtree_matches -> unit

method multiple_subtree_matches : 'a multiple_subtree_matches

val mutable multiple_node_matches : 'a multiple_node_matches option

method set_multiple_node_matches : 'a multiple_node_matches -> unit

method multiple_node_matches : 'a multiple_node_matches

val mutable adjacency_cache_hit_count : int

val mapping_comparison_cache : (bool
                                * bool
                                * bool
                                * bool
                                * Diffast_core.Misc.UID.t
                                * Diffast_core.Misc.UID.t
                                * Diffast_core.Misc.UID.t
                                * Diffast_core.Misc.UID.t,
                                 bool * int option * float option)
                                 Diffast_core.Misc.Tbl1.t

val mutable mapping_comparison_cache_hit_count : int

val similarity_cache : (bool * bool * bool,
                         Diffast_core.Misc.UID.t,
                         Diffast_core.Misc.UID.t,
                         float)
                         Diffast_core.Misc.Tbl3.t

val mutable similarity_cache_hit_count : int

val use_tbl1 : (B.ID.t, 'f list) Hashtbl.t

val use_tbl2 : (B.ID.t, 'f list) Hashtbl.t

val weak_node_eq_cache : ('a, 'a, bool) Diffast_core.Misc.Tbl2.t

method private use_tbl_add : (B.ID.t, 'f list) Hashtbl.t ->
  B.ID.t ->
  'f ->
  unit

method get_use1 : B.ID.t -> 'f list

method get_use2 : B.ID.t -> 'f list

method tree1 : 'b

method tree2 : 'b

method use_adjacency_cache : bool

method size_of_adjacency_cache : int

method adjacency_cache_hit_count : int

method use_similarity_cache : bool

method size_of_similarity_cache : int

method similarity_cache_hit_count : int

method use_mapping_comparison_cache : bool

method set_use_mapping_comparison_cache : unit

method clear_use_mapping_comparison_cache : unit

method size_of_mapping_comparison_cache : int

method mapping_comparison_cache_hit_count : int

method cache_path : string

method set_cache_path : string -> unit

method has_non_trivial_value : 'a -> bool

method has_trivial_value : 'a -> bool

method weak_node_eq : 'a -> 'a -> bool

method has_weak_non_trivial_value : 'a -> bool

method has_weak_non_trivial_tid : 'a -> bool

method has_weak_trivial_value : 'a -> bool

method eval_label_match : ?bonus_named:bool ->
  ?bonus_rename_pat:bool ->
  ?check_uniq:bool ->
  ?exact_only:bool ->
  'a ->
  'a ->
  int

method has_match1 : 'a -> bool

method has_match2 : 'a -> bool

method has_uniq_match : 'a -> 'a -> bool

method has_uniq_match1 : 'a -> bool

method has_uniq_match2 : 'a -> bool

val mutable num_to_be_notified1 : int

val mutable num_to_be_notified2 : int

method subtree_p_size : 'b -> ('a -> bool) -> 'a -> int

method get_num_to_be_notified1 : unit -> int

method get_num_to_be_notified2 : unit -> int

val many_matches_cache : (Obj.t, bool) Hashtbl.t

method has_many_matches : ?thresh:float -> 'a -> bool

method has_uniq_match_within_boundary : 'a -> 'a -> bool

method has_uniq_subtree_match : 'a -> 'a -> bool

method uniq_subtree_match_size : 'a -> 'a -> int

method has_uniq_subtree_match_within_boundary : 'a -> 'a -> bool

method get_child_having_use_rename : 'a ->
  'a ->
  < _replace_children : 
    ?initial:bool ->
    (int * Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2 array)
      list ->
    unit
  ; _set_is_collapsed : bool -> unit
  ; add_child : 
    int ->
    Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2 ->
    unit
  ; add_child_leftmost : 
    Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2 ->
    unit
  ; add_child_rightmost : 
    Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2 ->
    unit
  ; add_children_leftmost : 
    Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2 array ->
    unit
  ; add_children_rightmost : 
    Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2 array ->
    unit
  ; add_substance : 
    Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2 ->
    unit
  ; apath : Diffast_misc.Path.t
  ; begin_mutation : unit -> unit
  ; children : 
    Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2 array
  ; children_indexes : int list
  ; children_uids : Diffast_misc.UID.t list
  ; clear_collapsible : unit
  ; clear_in_path : unit
  ; collapse : int -> Diffast_misc.Xhash.t -> unit
  ; collapse_locked : bool
  ; collapse_not_locked : bool
  ; collapsible : bool
  ; data : 
    < _annotation : Obj.t
    ; _anonymized2_label : Obj.t
    ; _anonymized3_label : Obj.t
    ; _anonymized_label : Obj.t
    ; _digest : Diffast_misc.Xhash.t option
    ; _digest_string : string
    ; _label : Obj.t
    ; _set_digest : Diffast_core.Spec.SB.Xhash.t -> unit
    ; _stripped_label : Obj.t
    ; _stripped_orig_label : Obj.t
    ; add_binding : Diffast_core.Spec.Binding.t -> unit
    ; add_successor : 
      Diffast_core.Spec.node_data_t Diffast_core.Spec.Otree.node2 ->
      unit
    ; add_to_ordinal_list : int list -> unit
    ; anonymized2_label : string
    ; anonymized3_label : string
    ; anonymized_label : string
    ; binding : B.t
    ; bindings : Diffast_core.Spec.SB.Binding.t list
    ; change_attr : string -> string -> unit
    ; char : char
    ; delete_attr : string -> unit
    ; digest : Diffast_misc.Xhash.t option
    ; digest_string : string
    ; elem_attrs_for_delta : (string * string) list
    ; elem_name_for_delta : string
    ; eq : Diffast_core.Spec.node_data_t -> bool
    ; equals : Diffast_core.Spec.node_data_t -> bool
    ; feature : Obj.t * Diffast_core.Spec.SB.Xhash.t option
    ; frommacro : string
    ; get_category : string
    ; get_ident_use : string
    ; get_name : string
    ; get_ordinal : int -> int
    ; get_orig_name : string
    ; get_prefix : string
    ; get_stripped_name : string
    ; get_suffix : string
    ; get_value : string
    ; gid : Diffast_core.Spec.SB.Otree.GI.t
    ; has_non_trivial_tid : bool
    ; has_non_trivial_value : bool
    ; has_ordinal : bool
    ; has_value : bool
    ; id_loc : Diffast_core.Spec.Loc.t
    ; insert_attr : string -> string -> unit
    ; is_anonymous : bool
    ; is_anonymous_orig : bool
    ; is_block : bool
    ; is_boundary : bool
    ; is_common : bool
    ; is_compatible_with : ?weak:bool -> Diffast_core.Spec.node_data_t -> bool
    ; is_frommacro : bool
    ; is_int_literal : bool
    ; is_literal : bool
    ; is_named : bool
    ; is_named_orig : bool
    ; is_ntuple : bool
    ; is_op : bool
    ; is_order_insensitive : bool
    ; is_partition : bool
    ; is_phantom : bool
    ; is_primary : bool
    ; is_real_literal : bool
    ; is_scope_creating : bool
    ; is_sequence : bool
    ; is_special : bool
    ; is_statement : bool
    ; is_string_literal : bool
    ; label : string
    ; mid : Diffast_core.Spec.SB.MID.t
    ; more_anonymized_label : string
    ; move_disallowed : bool
    ; not_frommacro : bool
    ; orig_elem_attrs_for_delta : (string * string) list
    ; orig_elem_name_for_delta : string
    ; orig_lab_opt : Obj.t option
    ; orig_to_elem_data_for_delta : string * (string * string) list * string
    ; orig_to_elem_data_for_eq : string * (string * string) list * string
    ; quasi_eq : Diffast_core.Spec.node_data_t -> bool
    ; relabel_allowed : Diffast_core.Spec.node_data_t -> bool
    ; reset_digest : unit
    ; scope_node : Diffast_core.Spec.node_data_t Diffast_core.Spec.Otree.node2
    ; set_binding : Diffast_core.Spec.Binding.t -> unit
    ; set_bindings : Diffast_core.Spec.Binding.t list -> unit
    ; set_digest : Diffast_misc.Xhash.t -> unit
    ; set_frommacro : string -> unit
    ; set_gid : Diffast_core.Spec.SB.Otree.GI.t -> unit
    ; set_loc : Diffast_core.Spec.SB.Loc.t -> unit
    ; set_mid : Diffast_core.Spec.SB.MID.t -> unit
    ; set_prefix : string -> unit
    ; set_scope_node : 
      Diffast_core.Spec.node_data_t Diffast_core.Spec.Otree.node2 ->
      unit
    ; set_source_fid : string -> unit
    ; set_suffix : string -> unit
    ; set_weight : int -> unit
    ; source_fid : string
    ; src_loc : Diffast_core.Spec.SB.Loc.t
    ; stripped_label : string
    ; subtree_equals : Diffast_core.Spec.node_data_t -> bool
    ; successors : 
      Diffast_core.Spec.node_data_t Diffast_core.Spec.Otree.node2
        Diffast_core.Spec.Xset.t
    ; to_be_notified : bool
    ; to_elem_data : string * (string * string) list * string
    ; to_elem_data_for_delta : string * (string * string) list * string
    ; to_rep : string
    ; to_short_string : string
    ; to_simple_string : string
    ; to_string : string
    ; weight : int >
  ; decide_collapsible_or_not : unit
  ; del_leftmost_child : unit -> unit
  ; del_rightmost_child : unit -> unit
  ; end_mutation : ?overwrite:bool -> unit -> unit
  ; expand : unit
  ; get_substances : 
    Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2 list
  ; gindex : Diffast_core.Spec.SB.Otree.GI.t
  ; has_hidden_parent : bool
  ; has_initial_parent : bool
  ; has_later_mutation : bool
  ; has_parent : bool
  ; hash : int
  ; hidden_children : 
    Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2 array
  ; hidden_parent : 
    Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2
  ; hide_parent : unit
  ; in_path : bool
  ; index : int
  ; init_mutation : unit -> unit
  ; initial_ancestor_nodes : 
    Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2 list
  ; initial_children : 
    Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2 array
  ; initial_children_uids : Diffast_misc.UID.t list
  ; initial_nchildren : int
  ; initial_parent : 
    Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2
  ; initial_pos : int
  ; initial_to_string : string
  ; insert_path : 
    Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2 list ->
    unit
  ; is_collapsed : bool
  ; is_contracted : bool
  ; is_leaf : bool
  ; is_valid : bool
  ; iter_initial_ancestor_nodes : 
    (Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2 -> unit) ->
    unit
  ; lock_collapse : unit
  ; nchildren : int
  ; nth_child : 
    int ->
    Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2
  ; parent : Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2
  ; parent_edge : 
    Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2 option
  ; path : 
    Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2
      Diffast_core.Spec.SB.Otree.path
  ; pos : int
  ; preorder_index : int
  ; print : unit
  ; prune : unit
  ; prune_all_children : unit
  ; prune_children : int list -> unit
  ; prune_initial_children : int list -> unit
  ; prune_nth_child : int -> unit
  ; replace_children : 
    (int * Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2 array)
      list ->
    unit
  ; replace_nth_child : 
    int ->
    Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2 array ->
    unit
  ; set_apath : Diffast_misc.Path.t -> unit
  ; set_children : 
    Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2 array ->
    unit
  ; set_collapsible : unit
  ; set_data : Diffast_core.Spec.node_data_t -> unit
  ; set_digest : Diffast_misc.Xhash.t -> unit
  ; set_gindex : Diffast_core.Spec.SB.Otree.GI.t -> unit
  ; set_hidden_children : 
    Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2 array ->
    unit
  ; set_in_path : unit
  ; set_index : int -> unit
  ; set_initial_children : 
    Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2 array ->
    unit
  ; set_initial_parent : 
    Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2 ->
    unit
  ; set_initial_pos : int -> unit
  ; set_parent : 
    Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2 ->
    unit
  ; set_parent_edge : 
    Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2 option ->
    unit
  ; set_path : 
    Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2 list ->
    unit
  ; set_pos : int -> unit
  ; set_preorder_index : int -> unit
  ; to_dot : 
    ?mklab:
      (Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2 ->
        string) ->
    unit ->
    string
  ; to_dot_str : 
    ?mklab:
      (Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2 ->
        string) ->
    unit ->
    string
  ; to_dot_str_ini : 
    ?mklab:
      (Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2 ->
        string) ->
    unit ->
    string
  ; to_qualified_string : string
  ; to_rep : string
  ; to_string : string
  ; uid : Diffast_misc.UID.t
  ; unhide_parent : unit
  ; unlock_collapse : unit
  ; v_delete_child : int -> unit
  ; v_delete_children : int list -> unit
  ; v_insert_child : 
    ?later:bool ->
    ?offset:float ->
    int ->
    Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2 ->
    unit
  ; v_insert_children : 
    ?later:bool ->
    ?offset:float ->
    int ->
    Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2 list ->
    unit
  ; v_update_child : 
    int ->
    Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2 ->
    unit
  ; v_update_children : 
    int ->
    Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2 list ->
    unit >
  * < _replace_children : 
      ?initial:bool ->
      (int
       * Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2 array)
        list ->
      unit
  ; _set_is_collapsed : bool -> unit
  ; add_child : 
    int ->
    Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2 ->
    unit
  ; add_child_leftmost : 
    Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2 ->
    unit
  ; add_child_rightmost : 
    Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2 ->
    unit
  ; add_children_leftmost : 
    Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2 array ->
    unit
  ; add_children_rightmost : 
    Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2 array ->
    unit
  ; add_substance : 
    Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2 ->
    unit
  ; apath : Diffast_misc.Path.t
  ; begin_mutation : unit -> unit
  ; children : 
    Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2 array
  ; children_indexes : int list
  ; children_uids : Diffast_misc.UID.t list
  ; clear_collapsible : unit
  ; clear_in_path : unit
  ; collapse : int -> Diffast_misc.Xhash.t -> unit
  ; collapse_locked : bool
  ; collapse_not_locked : bool
  ; collapsible : bool
  ; data : 
    < _annotation : Obj.t
    ; _anonymized2_label : Obj.t
    ; _anonymized3_label : Obj.t
    ; _anonymized_label : Obj.t
    ; _digest : Diffast_misc.Xhash.t option
    ; _digest_string : string
    ; _label : Obj.t
    ; _set_digest : Diffast_core.Spec.SB.Xhash.t -> unit
    ; _stripped_label : Obj.t
    ; _stripped_orig_label : Obj.t
    ; add_binding : Diffast_core.Spec.Binding.t -> unit
    ; add_successor : 
      Diffast_core.Spec.node_data_t Diffast_core.Spec.Otree.node2 ->
      unit
    ; add_to_ordinal_list : int list -> unit
    ; anonymized2_label : string
    ; anonymized3_label : string
    ; anonymized_label : string
    ; binding : B.t
    ; bindings : Diffast_core.Spec.SB.Binding.t list
    ; change_attr : string -> string -> unit
    ; char : char
    ; delete_attr : string -> unit
    ; digest : Diffast_misc.Xhash.t option
    ; digest_string : string
    ; elem_attrs_for_delta : (string * string) list
    ; elem_name_for_delta : string
    ; eq : Diffast_core.Spec.node_data_t -> bool
    ; equals : Diffast_core.Spec.node_data_t -> bool
    ; feature : Obj.t * Diffast_core.Spec.SB.Xhash.t option
    ; frommacro : string
    ; get_category : string
    ; get_ident_use : string
    ; get_name : string
    ; get_ordinal : int -> int
    ; get_orig_name : string
    ; get_prefix : string
    ; get_stripped_name : string
    ; get_suffix : string
    ; get_value : string
    ; gid : Diffast_core.Spec.SB.Otree.GI.t
    ; has_non_trivial_tid : bool
    ; has_non_trivial_value : bool
    ; has_ordinal : bool
    ; has_value : bool
    ; id_loc : Diffast_core.Spec.Loc.t
    ; insert_attr : string -> string -> unit
    ; is_anonymous : bool
    ; is_anonymous_orig : bool
    ; is_block : bool
    ; is_boundary : bool
    ; is_common : bool
    ; is_compatible_with : ?weak:bool -> Diffast_core.Spec.node_data_t -> bool
    ; is_frommacro : bool
    ; is_int_literal : bool
    ; is_literal : bool
    ; is_named : bool
    ; is_named_orig : bool
    ; is_ntuple : bool
    ; is_op : bool
    ; is_order_insensitive : bool
    ; is_partition : bool
    ; is_phantom : bool
    ; is_primary : bool
    ; is_real_literal : bool
    ; is_scope_creating : bool
    ; is_sequence : bool
    ; is_special : bool
    ; is_statement : bool
    ; is_string_literal : bool
    ; label : string
    ; mid : Diffast_core.Spec.SB.MID.t
    ; more_anonymized_label : string
    ; move_disallowed : bool
    ; not_frommacro : bool
    ; orig_elem_attrs_for_delta : (string * string) list
    ; orig_elem_name_for_delta : string
    ; orig_lab_opt : Obj.t option
    ; orig_to_elem_data_for_delta : string * (string * string) list * string
    ; orig_to_elem_data_for_eq : string * (string * string) list * string
    ; quasi_eq : Diffast_core.Spec.node_data_t -> bool
    ; relabel_allowed : Diffast_core.Spec.node_data_t -> bool
    ; reset_digest : unit
    ; scope_node : Diffast_core.Spec.node_data_t Diffast_core.Spec.Otree.node2
    ; set_binding : Diffast_core.Spec.Binding.t -> unit
    ; set_bindings : Diffast_core.Spec.Binding.t list -> unit
    ; set_digest : Diffast_misc.Xhash.t -> unit
    ; set_frommacro : string -> unit
    ; set_gid : Diffast_core.Spec.SB.Otree.GI.t -> unit
    ; set_loc : Diffast_core.Spec.SB.Loc.t -> unit
    ; set_mid : Diffast_core.Spec.SB.MID.t -> unit
    ; set_prefix : string -> unit
    ; set_scope_node : 
      Diffast_core.Spec.node_data_t Diffast_core.Spec.Otree.node2 ->
      unit
    ; set_source_fid : string -> unit
    ; set_suffix : string -> unit
    ; set_weight : int -> unit
    ; source_fid : string
    ; src_loc : Diffast_core.Spec.SB.Loc.t
    ; stripped_label : string
    ; subtree_equals : Diffast_core.Spec.node_data_t -> bool
    ; successors : 
      Diffast_core.Spec.node_data_t Diffast_core.Spec.Otree.node2
        Diffast_core.Spec.Xset.t
    ; to_be_notified : bool
    ; to_elem_data : string * (string * string) list * string
    ; to_elem_data_for_delta : string * (string * string) list * string
    ; to_rep : string
    ; to_short_string : string
    ; to_simple_string : string
    ; to_string : string
    ; weight : int >
  ; decide_collapsible_or_not : unit
  ; del_leftmost_child : unit -> unit
  ; del_rightmost_child : unit -> unit
  ; end_mutation : ?overwrite:bool -> unit -> unit
  ; expand : unit
  ; get_substances : 
    Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2 list
  ; gindex : Diffast_core.Spec.SB.Otree.GI.t
  ; has_hidden_parent : bool
  ; has_initial_parent : bool
  ; has_later_mutation : bool
  ; has_parent : bool
  ; hash : int
  ; hidden_children : 
    Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2 array
  ; hidden_parent : 
    Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2
  ; hide_parent : unit
  ; in_path : bool
  ; index : int
  ; init_mutation : unit -> unit
  ; initial_ancestor_nodes : 
    Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2 list
  ; initial_children : 
    Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2 array
  ; initial_children_uids : Diffast_misc.UID.t list
  ; initial_nchildren : int
  ; initial_parent : 
    Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2
  ; initial_pos : int
  ; initial_to_string : string
  ; insert_path : 
    Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2 list ->
    unit
  ; is_collapsed : bool
  ; is_contracted : bool
  ; is_leaf : bool
  ; is_valid : bool
  ; iter_initial_ancestor_nodes : 
    (Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2 -> unit) ->
    unit
  ; lock_collapse : unit
  ; nchildren : int
  ; nth_child : 
    int ->
    Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2
  ; parent : Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2
  ; parent_edge : 
    Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2 option
  ; path : 
    Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2
      Diffast_core.Spec.SB.Otree.path
  ; pos : int
  ; preorder_index : int
  ; print : unit
  ; prune : unit
  ; prune_all_children : unit
  ; prune_children : int list -> unit
  ; prune_initial_children : int list -> unit
  ; prune_nth_child : int -> unit
  ; replace_children : 
    (int * Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2 array)
      list ->
    unit
  ; replace_nth_child : 
    int ->
    Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2 array ->
    unit
  ; set_apath : Diffast_misc.Path.t -> unit
  ; set_children : 
    Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2 array ->
    unit
  ; set_collapsible : unit
  ; set_data : Diffast_core.Spec.node_data_t -> unit
  ; set_digest : Diffast_misc.Xhash.t -> unit
  ; set_gindex : Diffast_core.Spec.SB.Otree.GI.t -> unit
  ; set_hidden_children : 
    Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2 array ->
    unit
  ; set_in_path : unit
  ; set_index : int -> unit
  ; set_initial_children : 
    Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2 array ->
    unit
  ; set_initial_parent : 
    Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2 ->
    unit
  ; set_initial_pos : int -> unit
  ; set_parent : 
    Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2 ->
    unit
  ; set_parent_edge : 
    Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2 option ->
    unit
  ; set_path : 
    Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2 list ->
    unit
  ; set_pos : int -> unit
  ; set_preorder_index : int -> unit
  ; to_dot : 
    ?mklab:
      (Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2 ->
        string) ->
    unit ->
    string
  ; to_dot_str : 
    ?mklab:
      (Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2 ->
        string) ->
    unit ->
    string
  ; to_dot_str_ini : 
    ?mklab:
      (Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2 ->
        string) ->
    unit ->
    string
  ; to_qualified_string : string
  ; to_rep : string
  ; to_string : string
  ; uid : Diffast_misc.UID.t
  ; unhide_parent : unit
  ; unlock_collapse : unit
  ; v_delete_child : int -> unit
  ; v_delete_children : int list -> unit
  ; v_insert_child : 
    ?later:bool ->
    ?offset:float ->
    int ->
    Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2 ->
    unit
  ; v_insert_children : 
    ?later:bool ->
    ?offset:float ->
    int ->
    Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2 list ->
    unit
  ; v_update_child : 
    int ->
    Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2 ->
    unit
  ; v_update_children : 
    int ->
    Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2 list ->
    unit >

method child_has_use_rename : 'a -> 'a -> bool

method is_def_and_has_use_rename : 'a -> 'a -> bool

method eval_label_match_list : ?bonus_named:bool ->
  ?bonus_rename_pat:bool ->
  ?flat:bool ->
  ?strip:bool ->
  ?check_uniq:bool ->
  ?exact_only:bool ->
  'a list ->
  'a list ->
  'a label_match_result

method estimate_cost_of_move : 'a Diffast_core.Node_mapping.c ->
  'a ->
  'a ->
  int

method find_ancestor_pairs_of_same_category : bool ->
  'a ->
  'a ->
  (int * int * 'a * 'a * int * int) list

method get_ancestors_similarity : ?take_boundary:bool ->
  ?strip:bool ->
  'a ->
  'a ->
  float

method get_similarity_score : ?ignore_cache:bool ->
  ?bonus_named:bool ->
  ?flat:bool ->
  'a ->
  'a ->
  float

method _get_adjacency_score : ?anchor:('a * 'a) option ->
  'a ->
  'a ->
  float * ('a * 'a) list

method get_adjacency_score : ?anchor:('a * 'a) option ->
  Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2 ->
  Diffast_core.Spec.node_data_t Diffast_core.Spec.SB.Otree.node2 ->
  float

method find_nearest_mapped_ancestor_pair : ('a -> 'a) -> 'a -> 'a -> 'a * 'a

method find_mapped_ancestor_pairs : ('a -> 'a) -> 'a -> 'a -> ('a * 'a) list

method check_parents : ?exact:bool ->
  'a Diffast_core.Node_mapping.c ->
  'a ->
  'a ->
  unit

method is_matched_subtree : 'a Diffast_core.Node_mapping.c ->
  'a ->
  'a ->
  'a ->
  bool

method has_matched_subtree : 'a Diffast_core.Node_mapping.c ->
  'a ->
  'a ->
  ?excluded:'a list ->
  'a ->
  bool

method check_op_mappings_m : 'a Diffast_core.Node_mapping.c ->
  'a ->
  'a ->
  'a ->
  'a ->
  bool

method check_op_mappings : 'a Diffast_core.Node_mapping.c ->
  int ->
  int ->
  'a ->
  'a ->
  'a ->
  'a ->
  bool

method compare_mappings : 'a Diffast_core.Node_mapping.c ->
  ?override:bool ->
  ?bonus_self:bool ->
  ?bonus_parent:bool ->
  ?force_prefer_crossing_count:bool ->
  'a ->
  'a ->
  ?ncrossing_old:int ref ->
  ?adjacency_old:float ref ->
  (int option -> float option -> bool -> unit) ->
  'a ->
  'a ->
  ?ncrossing_new:int ref ->
  ?adjacency_new:float ref ->
  (int option -> float option -> bool -> unit) ->
  unit

method elaborate_nmapping : ?multi:bool ->
  ?multi_node:bool ->
  'a Diffast_core.Node_mapping.c ->
  ('a * 'a) list * ('a * 'a) list