Module `Generic_vs_generic`

module A = Ast_generic

module B = Ast_generic

module MV = Metavars_generic

module Ast = Ast_generic

module Lib = Lib_ast

val verbose : bool ref

val pr2 : string -> unit

val _pr2_once : string -> unit

type tin = MV.metavars_binding

type tout = MV.metavars_binding list

type ('a, 'b) matcher = 'a -> 'b -> tin -> tout

val (>>=) : (tin -> tout) -> (unit -> tin -> tout) -> tin -> tout

val (>||>) : (tin -> tout) -> (tin -> tout) -> tin -> tout

val equal_ast_binded_code : Ast.any -> Ast.any -> bool

val check_and_add_metavar_binding : 
  (MV.mvar * Ast.any) ->
  (MV.mvar, Ast.any) Common2.assoc ->
  (MV.mvar, Ast.any) Common2.assoc option

val envf : (MV.mvar Ast.wrap, Ast.any) matcher

val empty_environment : unit -> 'a list

val return : unit -> tin -> tout

val fail : unit -> tin -> tout

val m_option : ('a, 'b) matcher -> ('a option, 'b option) matcher

val m_ref : ('a, 'b) matcher -> ('a ref, 'b ref) matcher

val m_list : ('a -> 'b -> tin -> tout) -> 'a list -> 'b list -> tin -> tout

val m_bool : 'a -> 'a -> tin -> tout

val m_string : string -> string -> tin -> tout

val m_other_xxx : 'a -> 'a -> tin -> tout

val m_info : 'a -> 'b -> tin -> tout

val m_tok : 'a -> 'b -> tin -> tout

val m_wrap : ('a -> 'b -> tin -> tout) -> ('a * 'c) -> ('b * 'd) -> tin -> tout

val m_ident : (MV.mvar * Ast.tok) -> B.ident -> tin -> tout

val m_dotted_name : (MV.mvar * Ast.tok) list -> B.ident list -> tin -> tout

val m_qualified_name : (MV.mvar * Ast.tok) list -> B.ident list -> tin -> tout

val m_module_name : A.module_name -> B.module_name -> tin -> tout

val m_resolved_name : A.resolved_name -> B.resolved_name -> tin -> tout

val m_name : A.name -> B.name -> tin -> tout

val m_expr : (A.expr, B.expr) matcher

val m_literal : A.literal -> B.literal -> tin -> tout

val m_action : A.action -> B.action -> tin -> tout

val m_arithmetic_operator : 
  A.arithmetic_operator ->
  B.arithmetic_operator ->
  tin ->
  tout

val m_special : A.special -> B.special -> tin -> tout

val m_id_info : A.id_info -> B.id_info -> tin -> tout

val m_container_operator : 
  A.container_operator ->
  B.container_operator ->
  tin ->
  tout

val m_other_expr_operator : 
  A.other_expr_operator ->
  B.other_expr_operator ->
  tin ->
  tout

val m_xml : A.xml -> B.xml -> tin -> tout

val m_arguments : A.arguments -> B.arguments -> tin -> tout

val m_list__m_argument : A.arguments -> B.arguments -> tin -> tout

val m_argument : A.argument -> A.argument -> tin -> tout

val m_other_argument_operator : 
  A.other_argument_operator ->
  B.other_argument_operator ->
  tin ->
  tout

val m_type_ : (A.type_, B.type_) matcher

val m_type_arguments : (A.type_arguments, B.type_arguments) matcher

val m_type_argument : A.type_argument -> B.type_argument -> tin -> tout

val m_other_type_operator : 
  A.other_type_operator ->
  B.other_type_operator ->
  tin ->
  tout

val m_other_type_argument_operator : 
  A.other_type_argument_operator ->
  B.other_type_argument_operator ->
  tin ->
  tout

val m_attribute : A.attribute -> B.attribute -> tin -> tout

val m_other_attribute_operator : 
  A.other_attribute_operator ->
  B.other_attribute_operator ->
  tin ->
  tout

val m_stmt : A.stmt -> B.stmt -> tin -> tout

val m_for_header : A.for_header -> B.for_header -> tin -> tout

val m_for_var_or_expr : A.for_var_or_expr -> B.for_var_or_expr -> tin -> tout

val m_label : A.label -> B.label -> tin -> tout

val m_catch : A.catch -> B.catch -> tin -> tout

val m_finally : (A.finally, B.finally) matcher

val m_case_and_body : A.case_and_body -> B.case_and_body -> tin -> tout

val m_case : A.case -> B.case -> tin -> tout

val m_other_stmt_operator : 
  A.other_stmt_operator ->
  B.other_stmt_operator ->
  tin ->
  tout

val m_pattern : A.pattern -> B.pattern -> tin -> tout

val m_field_pattern : A.field_pattern -> B.field_pattern -> tin -> tout

val m_other_pattern_operator : 
  A.other_pattern_operator ->
  B.other_pattern_operator ->
  tin ->
  tout

val m_definition : A.definition -> B.definition -> tin -> tout

val m_entity : A.entity -> B.entity -> tin -> tout

val m_definition_kind : A.definition_kind -> B.definition_kind -> tin -> tout

val m_type_parameter_constraint : 
  A.type_parameter_constraint ->
  B.type_parameter_constraint ->
  tin ->
  tout

val m_type_parameter_constraints : 
  A.type_parameter_constraints ->
  B.type_parameter_constraints ->
  tin ->
  tout

val m_type_parameter : A.type_parameter -> B.type_parameter -> tin -> tout

val m_function_definition : 
  A.function_definition ->
  B.function_definition ->
  tin ->
  tout

val m_parameters : A.parameters -> B.parameters -> tin -> tout

val m_parameter : A.parameter -> B.parameter -> tin -> tout

val m_parameter_classic : 
  A.parameter_classic ->
  B.parameter_classic ->
  tin ->
  tout

val m_other_parameter_operator : 
  A.other_parameter_operator ->
  B.other_parameter_operator ->
  tin ->
  tout

val m_variable_definition : 
  A.variable_definition ->
  B.variable_definition ->
  tin ->
  tout

val m_field : A.field -> B.field -> tin -> tout

val m_type_definition : A.type_definition -> B.type_definition -> tin -> tout

val m_type_definition_kind : 
  A.type_definition_kind ->
  B.type_definition_kind ->
  tin ->
  tout

val m_or_type : A.or_type_element -> B.or_type_element -> tin -> tout

val m_other_type_kind_operator : 
  A.other_type_kind_operator ->
  B.other_type_kind_operator ->
  tin ->
  tout

val m_other_or_type_element_operator : 
  A.other_or_type_element_operator ->
  B.other_or_type_element_operator ->
  tin ->
  tout

val m_class_definition : 
  A.class_definition ->
  B.class_definition ->
  tin ->
  tout

val m_class_kind : A.class_kind -> B.class_kind -> tin -> tout

val m_module_definition : 
  A.module_definition ->
  B.module_definition ->
  tin ->
  tout

val m_module_definition_kind : 
  A.module_definition_kind ->
  B.module_definition_kind ->
  tin ->
  tout

val m_other_module_operator : 
  A.other_module_operator ->
  B.other_module_operator ->
  tin ->
  tout

val m_macro_definition : 
  A.macro_definition ->
  B.macro_definition ->
  tin ->
  tout

val m_directive : A.directive -> B.directive -> tin -> tout

val m_alias : A.alias -> B.alias -> tin -> tout

val m_other_directive_operator : 
  A.other_directive_operator ->
  B.other_directive_operator ->
  tin ->
  tout

val m_item : A.item -> B.item -> tin -> tout

val m_program : A.program -> B.program -> tin -> tout

val m_any : A.any -> B.any -> tin -> tout

Install

Dune Dependency

Authors

Maintainers

Sources

doc/pfff-matcher/Generic_vs_generic/index.html

Module `Generic_vs_generic`

package pfff

Install

Dune Dependency

Authors

Maintainers

Sources

doc/pfff-matcher/Generic_vs_generic/index.html

Module Generic_vs_generic

Module `Generic_vs_generic`