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 (_, c)) as id), then_stmt, else_stmt))] ->
  70         super#on_expr { env with rx_is_enabled_allowed = SN.Rx.is_enabled c } 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 (ct, ((_, Id (_, cn)) as e1), ta, el, unpacked_element))
  78         when String.equal cn SN.Rx.move ->
  79         self#on_Call
  80           { env with rx_move_allowed = false }
  81           ct
  82           e1
  83           ta
  84           el
  85           unpacked_element
  86       | (_, Call (ct, e1, ta, el, unpacked_element)) ->
  87         self#on_Call
  88           { env with rx_move_allowed = true }
  89           ct
  90           e1
  91           ta
  92           el
  93           unpacked_element
  94       | (_, Binop (Ast_defs.Eq None, e1, rhs)) ->
  95         self#on_Binop
  96           { env with rx_move_allowed = true }
  97           (Ast_defs.Eq None)
  98           e1
  99           rhs
 100       | _ -> super#on_expr { env with rx_move_allowed = false } e
 101   end
 102
 103 class virtual ['state] iter_with_state =
 104   object (self)
 105     inherit [_] Aast.iter as super
 106
 107     (* Entry point *)
 108     method go
 109         (state : 'state) (ctx : Provider_context.t) (program : Nast.program) =
 110       self#on_list (fun () -> self#go_def state ctx) () program
 111
 112     method go_def state ctx x = self#on_def (def_env ctx x, state) x
 113
 114     method! on_fun_ (env, state) x = super#on_fun_ (fun_env env x, state) x
 115   end
 116
 117 class type handler =
 118   object
 119     method at_fun_ : env -> Nast.fun_ -> unit
 120
 121     method at_class_ : env -> Nast.class_ -> unit
 122
 123     method at_method_ : env -> Nast.method_ -> unit
 124
 125     method at_record_def : env -> Nast.record_def -> unit
 126
 127     method at_expr : env -> Nast.expr -> unit
 128
 129     method at_stmt : env -> Nast.stmt -> unit
 130
 131     method at_hint : env -> hint -> unit
 132
 133     method at_typedef : env -> Nast.typedef -> unit
 134
 135     method at_method_redeclaration : env -> Nast.method_redeclaration -> unit
 136
 137     method at_gconst : env -> Nast.gconst -> unit
 138   end
 139
 140 class virtual handler_base : handler =
 141   object
 142     method at_fun_ _ _ = ()
 143
 144     method at_class_ _ _ = ()
 145
 146     method at_method_ _ _ = ()
 147
 148     method at_record_def _ _ = ()
 149
 150     method at_expr _ _ = ()
 151
 152     method at_stmt _ _ = ()
 153
 154     method at_hint _ _ = ()
 155
 156     method at_typedef _ _ = ()
 157
 158     method at_method_redeclaration _ _ = ()
 159
 160     method at_gconst _ _ = ()
 161   end
 162
 163 let iter_with (handlers : handler list) : iter =
 164   object
 165     inherit iter as super
 166
 167     method! on_fun_ env x =
 168       List.iter handlers (fun v -> v#at_fun_ env x);
 169       super#on_fun_ env x
 170
 171     method! on_class_ env x =
 172       List.iter handlers (fun v -> v#at_class_ env x);
 173       super#on_class_ env x
 174
 175     method! on_method_ env x =
 176       List.iter handlers (fun v -> v#at_method_ env x);
 177       super#on_method_ env x
 178
 179     method! on_record_def env x =
 180       List.iter handlers (fun v -> v#at_record_def env x);
 181       super#on_record_def env x
 182
 183     method! on_expr env x =
 184       List.iter handlers (fun v -> v#at_expr env x);
 185       super#on_expr env x
 186
 187     method! on_stmt env x =
 188       List.iter handlers (fun v -> v#at_stmt env x);
 189       super#on_stmt env x
 190
 191     method! on_hint env h =
 192       List.iter handlers (fun v -> v#at_hint env h);
 193       super#on_hint env h
 194
 195     method! on_typedef env t =
 196       List.iter handlers (fun v -> v#at_typedef env t);
 197       super#on_typedef env t
 198
 199     method! on_method_redeclaration env mr =
 200       List.iter handlers (fun v -> v#at_method_redeclaration env mr);
 201       super#on_method_redeclaration env mr
 202
 203     method! on_gconst env gconst =
 204       List.iter handlers (fun v -> v#at_gconst env gconst);
 205       super#on_gconst env gconst
 206   end