package rotor

You can search for identifiers within the package.

in-package search v0.2.0

An automatic refactoring tool for OCaml

Install

dune-project

Dependency

trustworthy-refactoring.gitlab.io Readme Edit opam file Versions (1)

Authors

Maintainers

R

Reuben N. S. Rowe <reuben.rowe@cantab.net>

Sources

rotor-0.1.zip

md5=372ca9b6a7af2fdd99d5117d376870b4

sha512=6f5473951437a48bf9ae7a5d22a4283c02bed6a6e5c7bc02fc5f28dc5c28720f3e2c69f32a2a0c5b9447c2bc8c83746bb4de5b67909a98cc8921527582727063

doc/rotor/Rotor_env/index.html

Module `Rotor_env`

include module type of Compiler_import.Env

type summary = Env.summary =

| Env_empty
| Env_value of summary * Ident.t * Types.value_description
| Env_type of summary * Ident.t * Types.type_declaration
| Env_extension of summary * Ident.t * Types.extension_constructor
| Env_module of summary * Ident.t * Types.module_presence * Types.module_declaration
| Env_modtype of summary * Ident.t * Types.modtype_declaration
| Env_class of summary * Ident.t * Types.class_declaration
| Env_cltype of summary * Ident.t * Types.class_type_declaration
| Env_open of summary * Path.t
| Env_functor_arg of summary * Ident.t
| Env_constraints of summary * Types.type_declaration Path.Map.t
| Env_copy_types of summary * string list
| Env_persistent of summary * Ident.t

type address = Env.address =

| Aident of Ident.t
| Adot of address * int

type t = Env.t

val empty : t

val initial_safe_string : t

val initial_unsafe_string : t

val diff : t -> t -> Ident.t list

val copy_local : from:t -> t -> t

type type_descriptions =
  Types.constructor_description list * Types.label_description list

type iter_cont = Env.iter_cont

val iter_types : 
  (Path.t -> (Path.t * (Types.type_declaration * type_descriptions)) -> unit) ->
  t ->
  iter_cont

val run_iter_cont : iter_cont list -> (Path.t * iter_cont) list

val same_types : t -> t -> bool

val used_persistent : unit -> Types.Concr.t

val find_shadowed_types : Path.t -> t -> Path.t list

val without_cmis : ('a -> 'b) -> 'a -> 'b

val find_value : Path.t -> t -> Types.value_description

val find_type : Path.t -> t -> Types.type_declaration

val find_type_descrs : Path.t -> t -> type_descriptions

val find_module : Path.t -> t -> Types.module_declaration

val find_modtype : Path.t -> t -> Types.modtype_declaration

val find_class : Path.t -> t -> Types.class_declaration

val find_cltype : Path.t -> t -> Types.class_type_declaration

val find_type_expansion : 
  Path.t ->
  t ->
  Types.type_expr list * Types.type_expr * int

val find_type_expansion_opt : 
  Path.t ->
  t ->
  Types.type_expr list * Types.type_expr * int

val find_modtype_expansion : Path.t -> t -> Types.module_type

val find_value_address : Path.t -> t -> address

val find_module_address : Path.t -> t -> address

val find_class_address : Path.t -> t -> address

val find_constructor_address : Path.t -> t -> address

val add_functor_arg : Ident.t -> t -> t

val is_functor_arg : Path.t -> t -> bool

val normalize_type_path : Location.t option -> t -> Path.t -> Path.t

val normalize_path_prefix : Location.t option -> t -> Path.t -> Path.t

val reset_required_globals : unit -> unit

val get_required_globals : unit -> Ident.t list

val add_required_global : Ident.t -> unit

val has_local_constraints : t -> bool

val lookup_value : 
  ?loc:Location.t ->
  ?mark:bool ->
  Longident.t ->
  t ->
  Path.t * Types.value_description

val lookup_constructor : 
  ?loc:Location.t ->
  ?mark:bool ->
  Longident.t ->
  t ->
  Types.constructor_description

val lookup_all_constructors : 
  ?loc:Location.t ->
  ?mark:bool ->
  Longident.t ->
  t ->
  (Types.constructor_description * (unit -> unit)) list

val lookup_label : 
  ?loc:Location.t ->
  ?mark:bool ->
  Longident.t ->
  t ->
  Types.label_description

val lookup_all_labels : 
  ?loc:Location.t ->
  ?mark:bool ->
  Longident.t ->
  t ->
  (Types.label_description * (unit -> unit)) list

val lookup_type : ?loc:Location.t -> ?mark:bool -> Longident.t -> t -> Path.t

val lookup_module : 
  load:bool ->
  ?loc:Location.t ->
  ?mark:bool ->
  Longident.t ->
  t ->
  Path.t

val lookup_modtype : 
  ?loc:Location.t ->
  ?mark:bool ->
  Longident.t ->
  t ->
  Path.t * Types.modtype_declaration

val lookup_class : 
  ?loc:Location.t ->
  ?mark:bool ->
  Longident.t ->
  t ->
  Path.t * Types.class_declaration

val lookup_cltype : 
  ?loc:Location.t ->
  ?mark:bool ->
  Longident.t ->
  t ->
  Path.t * Types.class_type_declaration

type copy_of_types = Env.copy_of_types

val make_copy_of_types : string list -> t -> copy_of_types

val do_copy_types : copy_of_types -> t -> t

exception Recmodule

val add_value : 
  ?check:(string -> Warnings.t) ->
  Ident.t ->
  Types.value_description ->
  t ->
  t

val add_type : check:bool -> Ident.t -> Types.type_declaration -> t -> t

val add_extension : 
  check:bool ->
  Ident.t ->
  Types.extension_constructor ->
  t ->
  t

val add_module : 
  ?arg:bool ->
  Ident.t ->
  Types.module_presence ->
  Types.module_type ->
  t ->
  t

val add_module_declaration : 
  ?arg:bool ->
  check:bool ->
  Ident.t ->
  Types.module_presence ->
  Types.module_declaration ->
  t ->
  t

val add_modtype : Ident.t -> Types.modtype_declaration -> t -> t

val add_class : Ident.t -> Types.class_declaration -> t -> t

val add_cltype : Ident.t -> Types.class_type_declaration -> t -> t

val add_local_type : Path.t -> Types.type_declaration -> t -> t

val add_persistent_structure : Ident.t -> t -> t

val persistent_structures_of_dir : Load_path.Dir.t -> Misc.Stdlib.String.Set.t

val filter_non_loaded_persistent : (Ident.t -> bool) -> t -> t

val add_item : Types.signature_item -> t -> t

val add_signature : Types.signature -> t -> t

val open_signature : 
  ?used_slot:bool ref ->
  ?loc:Location.t ->
  ?toplevel:bool ->
  Asttypes.override_flag ->
  Path.t ->
  t ->
  t option

val open_pers_signature : string -> t -> t

val enter_value : 
  ?check:(string -> Warnings.t) ->
  string ->
  Types.value_description ->
  t ->
  Ident.t * t

val enter_type : 
  scope:int ->
  string ->
  Types.type_declaration ->
  t ->
  Ident.t * t

val enter_extension : 
  scope:int ->
  string ->
  Types.extension_constructor ->
  t ->
  Ident.t * t

val enter_module : 
  scope:int ->
  ?arg:bool ->
  string ->
  Types.module_presence ->
  Types.module_type ->
  t ->
  Ident.t * t

val enter_module_declaration : 
  ?arg:bool ->
  Ident.t ->
  Types.module_presence ->
  Types.module_declaration ->
  t ->
  t

val enter_modtype : 
  scope:int ->
  string ->
  Types.modtype_declaration ->
  t ->
  Ident.t * t

val enter_class : 
  scope:int ->
  string ->
  Types.class_declaration ->
  t ->
  Ident.t * t

val enter_cltype : 
  scope:int ->
  string ->
  Types.class_type_declaration ->
  t ->
  Ident.t * t

val enter_signature : scope:int -> Types.signature -> t -> Types.signature * t

val reset_cache : unit -> unit

val reset_cache_toplevel : unit -> unit

val set_unit_name : string -> unit

val get_unit_name : unit -> string

val read_signature : string -> string -> Types.signature

val save_signature : 
  alerts:string Misc.Stdlib.String.Map.t ->
  Types.signature ->
  string ->
  string ->
  Cmi_format.cmi_infos

val save_signature_with_imports : 
  alerts:string Misc.Stdlib.String.Map.t ->
  Types.signature ->
  string ->
  string ->
  (string * Digest.t option) list ->
  Cmi_format.cmi_infos

val crc_of_unit : string -> Digest.t

val imports : unit -> (string * Digest.t option) list

val is_imported_opaque : string -> bool

val crc_units : Consistbl.t

val add_import : string -> unit

val summary : t -> summary

val keep_only_summary : t -> t

val env_of_only_summary : (summary -> Subst.t -> t) -> t -> t

type error = Env.error =

| Illegal_renaming of string * string * string
| Inconsistent_import of string * string * string
| Need_recursive_types of string * string
| Depend_on_unsafe_string_unit of string * string
| Missing_module of Location.t * Path.t * Path.t
| Illegal_value_name of Location.t * string

exception Error of error

val report_error : Format.formatter -> error -> unit

val mark_value_used : string -> Types.value_description -> unit

val mark_module_used : string -> Location.t -> unit

val mark_type_used : string -> Types.type_declaration -> unit

type constructor_usage = Env.constructor_usage =

| Positive
| Pattern
| Privatize

val mark_constructor_used : 
  constructor_usage ->
  string ->
  Types.type_declaration ->
  string ->
  unit

val mark_constructor : 
  constructor_usage ->
  t ->
  string ->
  Types.constructor_description ->
  unit

val mark_extension_used : 
  constructor_usage ->
  Types.extension_constructor ->
  string ->
  unit

val in_signature : bool -> t -> t

val is_in_signature : t -> bool

val set_value_used_callback : 
  string ->
  Types.value_description ->
  (unit -> unit) ->
  unit

val set_type_used_callback : 
  string ->
  Types.type_declaration ->
  ((unit -> unit) -> unit) ->
  unit

val check_modtype_inclusion : 
  (loc:Location.t ->
    t ->
    Types.module_type ->
    Path.t ->
    Types.module_type ->
    unit)
    ref

val check_well_formed_module : 
  (t -> Location.t -> string -> Types.module_type -> unit) ref

val add_delayed_check_forward : ((unit -> unit) -> unit) ref

val strengthen : 
  (aliasable:bool -> t -> Types.module_type -> Path.t -> Types.module_type) ref

val same_constr : (t -> Types.type_expr -> Types.type_expr -> bool) ref

val fold_values : 
  (string -> Path.t -> Types.value_description -> 'a -> 'a) ->
  Longident.t option ->
  t ->
  'a ->
  'a

val fold_types : 
  (string ->
    Path.t ->
    (Types.type_declaration * type_descriptions) ->
    'a ->
    'a) ->
  Longident.t option ->
  t ->
  'a ->
  'a

val fold_constructors : 
  (Types.constructor_description -> 'a -> 'a) ->
  Longident.t option ->
  t ->
  'a ->
  'a

val fold_labels : 
  (Types.label_description -> 'a -> 'a) ->
  Longident.t option ->
  t ->
  'a ->
  'a

val fold_modules : 
  (string -> Path.t -> Types.module_declaration -> 'a -> 'a) ->
  Longident.t option ->
  t ->
  'a ->
  'a

val fold_modtypes : 
  (string -> Path.t -> Types.modtype_declaration -> 'a -> 'a) ->
  Longident.t option ->
  t ->
  'a ->
  'a

val fold_classes : 
  (string -> Path.t -> Types.class_declaration -> 'a -> 'a) ->
  Longident.t option ->
  t ->
  'a ->
  'a

val fold_cltypes : 
  (string -> Path.t -> Types.class_type_declaration -> 'a -> 'a) ->
  Longident.t option ->
  t ->
  'a ->
  'a

val scrape_alias : t -> Types.module_type -> Types.module_type

val check_value_name : string -> Location.t -> unit

val print_address : Format.formatter -> address -> unit

module Persistent_signature : sig ... end

val normalize_module_path : 
  Compiler_import.Location.t option ->
  t ->
  Compiler_import.Path.t ->
  Compiler_import.Path.t

val normalize_mty_path : 
  ?lax:bool ->
  t ->
  Compiler_import.Path.t ->
  Compiler_import.Path.t