hphp/hack/src/typing/nast_visitor.ml

   1 (*
   2  * Copyright (c) 2018, Facebook, Inc.
   3  * All rights reserved.
   4  *
   5  * This source code is licensed under the MIT license found in the
   6  * LICENSE file in the "hack" directory of this source tree.
   7  *
   8  *)
   9
  10 open Hh_prelude
  11 open Aast
  12 open Nast_check_env
  13 module SN = Naming_special_names
  14
  15 class virtual iter =
  16   object (self)
  17     inherit [_] Aast.iter as super
  18
  19     (* Entry point *)
  20     method go (ctx : Provider_context.t) (program : Nast.program) =
  21       self#on_list (fun () -> self#go_def ctx) () program
  22
  23     method go_def ctx x = self#on_def (def_env ctx x) x
  24
  25     method! on_fun_ env x = super#on_fun_ (fun_env env x) x
  26
  27     method! on_method_ env x = super#on_method_ (method_env env x) x
  28
  29     method! on_class_ env x = super#on_class_ (class_env env x) x
  30
  31     method! on_Try env b cl fb =
  32       self#on_block { env with is_finally = true } fb;
  33       super#on_Try env b cl fb
  34
  35     method! on_Do env = super#on_Do { env with control_context = LoopContext }
  36
  37     method! on_While env =
  38       super#on_While { env with control_context = LoopContext }
  39
  40     method! on_For env = super#on_For { env with control_context = LoopContext }
  41
  42     method! on_Foreach env =
  43       super#on_Foreach { env with control_context = LoopContext }
  44
  45     method! on_Switch env =
  46       super#on_Switch { env with control_context = SwitchContext }
  47
  48     method! on_Efun env =
  49       super#on_Efun { env with is_finally = false; control_context = Toplevel }
  50
  51     method! on_Lfun env =
  52       super#on_Lfun { env with is_finally = false; control_context = Toplevel }
  53
  54     method! on_Obj_get env =
  55       super#on_Obj_get { env with array_append_allowed = false }
  56
  57     method! on_Array_get env =
  58       super#on_Array_get { env with array_append_allowed = false }
  59
  60     method! on_Binop env op e1 e2 =
  61       match op with
  62       | Ast_defs.Eq None ->
  63         self#on_expr { env with array_append_allowed = true } e1;
  64         self#on_expr env e2
  65       | _ -> super#on_Binop env op e1 e2
  66
  67     method! on_func_body env fb =
  68       match fb.fb_ast with
  69       | [(_, If (((_, Id (_, _)) as id), then_stmt, else_stmt))] ->
  70         super#on_expr env id;
  71         self#on_block env then_stmt;
  72         self#on_block env else_stmt
  73       | _ -> super#on_func_body env fb
  74
  75     method! on_expr env e =
  76       match e with
  77       | (_, Call (e1, ta, el, unpacked_element)) ->
  78         self#on_Call env e1 ta el unpacked_element
  79       | (_, Binop (Ast_defs.Eq None, e1, rhs)) ->
  80         self#on_Binop env (Ast_defs.Eq None) e1 rhs
  81       | _ -> super#on_expr env e
  82   end
  83
  84 class virtual ['state] iter_with_state =
  85   object (self)
  86     inherit [_] Aast.iter as super
  87
  88     (* Entry point *)
  89     method go
  90         (state : 'state) (ctx : Provider_context.t) (program : Nast.program) =
  91       self#on_list (fun () -> self#go_def state ctx) () program
  92
  93     method go_def state ctx x = self#on_def (def_env ctx x, state) x
  94
  95     method! on_fun_ (env, state) x = super#on_fun_ (fun_env env x, state) x
  96   end
  97
  98 class type handler =
  99   object
 100     method at_fun_ : env -> Nast.fun_ -> unit
 101
 102     method at_class_ : env -> Nast.class_ -> unit
 103
 104     method at_method_ : env -> Nast.method_ -> unit
 105
 106     method at_record_def : env -> Nast.record_def -> unit
 107
 108     method at_expr : env -> Nast.expr -> unit
 109
 110     method at_stmt : env -> Nast.stmt -> unit
 111
 112     method at_hint : env -> hint -> unit
 113
 114     method at_contexts : env -> contexts -> unit
 115
 116     method at_typedef : env -> Nast.typedef -> unit
 117
 118     method at_gconst : env -> Nast.gconst -> unit
 119   end
 120
 121 class virtual handler_base : handler =
 122   object
 123     method at_fun_ _ _ = ()
 124
 125     method at_class_ _ _ = ()
 126
 127     method at_method_ _ _ = ()
 128
 129     method at_record_def _ _ = ()
 130
 131     method at_expr _ _ = ()
 132
 133     method at_stmt _ _ = ()
 134
 135     method at_hint _ _ = ()
 136
 137     method at_contexts _ _ = ()
 138
 139     method at_typedef _ _ = ()
 140
 141     method at_gconst _ _ = ()
 142   end
 143
 144 let iter_with (handlers : handler list) : iter =
 145   object
 146     inherit iter as super
 147
 148     method! on_fun_ env x =
 149       List.iter handlers (fun v -> v#at_fun_ env x);
 150       super#on_fun_ env x
 151
 152     method! on_class_ env x =
 153       List.iter handlers (fun v -> v#at_class_ env x);
 154       super#on_class_ env x
 155
 156     method! on_method_ env x =
 157       List.iter handlers (fun v -> v#at_method_ env x);
 158       super#on_method_ env x
 159
 160     method! on_record_def env x =
 161       List.iter handlers (fun v -> v#at_record_def env x);
 162       super#on_record_def env x
 163
 164     method! on_expr env x =
 165       List.iter handlers (fun v -> v#at_expr env x);
 166       super#on_expr env x
 167
 168     method! on_stmt env x =
 169       List.iter handlers (fun v -> v#at_stmt env x);
 170       super#on_stmt env x
 171
 172     method! on_hint env h =
 173       List.iter handlers (fun v -> v#at_hint env h);
 174       super#on_hint env h
 175
 176     method! on_contexts env cl =
 177       List.iter handlers (fun v -> v#at_contexts env cl);
 178       super#on_contexts env cl
 179
 180     method! on_typedef env t =
 181       List.iter handlers (fun v -> v#at_typedef env t);
 182       super#on_typedef env t
 183
 184     method! on_gconst env gconst =
 185       List.iter handlers (fun v -> v#at_gconst env gconst);
 186       super#on_gconst env gconst
 187   end