Class Sexp
In: lib/ruby_parser/bm_sexp.rb
Parent: Object

Sexp changes from ruby_parser and some changes for caching hash value and tracking ‘original’ line number of a Sexp.

Methods

<<   arglist   arglist=   args   block   block_args   block_call   body   body=   body_list   call   call_chain   class_name   combine   compact   condition   condition=   deep_clone   each_arg   each_arg!   else_clause   expect   find_and_replace_all   find_node   first_arg   first_arg=   first_param   formal_args   hash   inspect   last_arg   lhs   lhs=   method   method=   method_missing   method_name   module   module_name   node_type=   paren   parent_name   render_type   result_class   rhs   rhs=   second   second_arg   second_arg=   set_args   target   target=   then_clause   third_arg   third_arg=   to_sym   value   value=  

Constants

ASSIGNMENT_BOOL = [:gasgn, :iasgn, :lasgn, :cvdecl, :cvasgn, :cdecl, :or, :and, :colon2, :op_asgn_or]
CALLS = [:call, :attrasgn, :safe_call, :safe_attrasgn]

External Aliases

sexp_type -> node_type
sexp_body -> values
<< -> old_push
compact -> old_compact
find_and_replace_all -> old_fara
find_node -> old_find_node

Attributes

or_depth  [RW] 
original_line  [RW] 

Public Instance methods

arglist()

Returns arglist for method call. This differs from Sexp#args, as Sexp#args does not return a ‘real’ Sexp (it does not have a node type) but Sexp#arglist returns a s(:arglist, …) 

    s(:call, s(:call, nil, :x, s(:arglist)), :y, s(:arglist, s(:lit, 1), s(:lit, 2)))
                                                 ^------------ arglist ------------^
args()

Returns arguments of a method call. This will be an ‘untyped’ Sexp. 

    s(:call, s(:call, nil, :x, s(:arglist)), :y, s(:arglist, s(:lit, 1), s(:lit, 2)))
                                                             ^--------args--------^
block(delete = nil)

Returns block of a call with a block. Could be a single expression or a block: 

    s(:iter,
     s(:call, nil, :x, s(:arglist)),
      s(:lasgn, :y),
       s(:block, s(:lvar, :y), s(:call, nil, :z, s(:arglist))))
       ^-------------------- block --------------------------^
block_args()

Returns parameters for a block 

    s(:iter,
     s(:call, nil, :x, s(:arglist)),
      s(:lasgn, :y), <- block_args
       s(:call, nil, :p, s(:arglist, s(:lvar, :y))))
block_call()

Method call associated with a block: 

    s(:iter,
     s(:call, nil, :x, s(:arglist)), <- block_call
      s(:lasgn, :y),
       s(:block, s(:lvar, :y), s(:call, nil, :z, s(:arglist))))
body()

Returns body of a method definition, class, or module. This will be an untyped Sexp containing a list of Sexps from the body.

body=(exp)

Sets body, which is now a complicated process because the body is no longer a separate Sexp, but just a list of Sexps.

body_list()

Like Sexp#body, except the returned Sexp is of type :rlist instead of untyped.

call()

Returns the call Sexp in a result returned from FindCall

combine(exp, line = nil)

Join self and exp into an :or Sexp. Sets or_depth. Used for combining "branched" values in AliasProcessor.

condition()

Returns condition of an if expression: 

    s(:if,
     s(:lvar, :condition), <-- condition
     s(:lvar, :then_val),
     s(:lvar, :else_val)))
deep_clone(line = nil)

Create clone of Sexp and nested Sexps but not their non-Sexp contents. If a line number is provided, also sets line/original_line on all Sexps.

else_clause()

Returns ‘else’ clause of an if expression: 

    s(:if,
     s(:lvar, :condition),
     s(:lvar, :then_val),
     s(:lvar, :else_val)))
     ^---else caluse---^
expect(*types)

Raise a WrongSexpError if the nodes type does not match one of the expected types.

first_arg()

Returns first argument of a method call.

first_arg=(exp)

Sets first argument of a method call.

lhs()

Returns the left hand side of assignment or boolean: 

    s(:lasgn, :x, s(:lit, 1))
               ^--lhs
lhs=(exp)

Sets the left hand side of assignment or boolean.

method()

Returns method of a method call:

s(:call, s(:call, nil, :x, s(:arglist)), :y, s(:arglist, s(:lit, 1))) 

                        ^- method
method_name()

Returns name of method being defined in a method definition.

module()

Returns the module the call is inside

module_name()

Alias for class_name

result_class()

Return the class the call is inside

rhs()

Returns right side (value) of assignment or boolean: 

    s(:lasgn, :x, s(:lit, 1))
                  ^--rhs---^
rhs=(exp)

Sets the right hand side of assignment or boolean.

second_arg()

Returns second argument of a method call.

second_arg=(exp)

Sets second argument of a method call.

target()

Returns target of a method call:

s(:call, s(:call, nil, :x, s(:arglist)), :y, s(:arglist, s(:lit, 1))) 

         ^-----------target-----------^
then_clause()

Returns ‘then’ clause of an if expression: 

    s(:if,
     s(:lvar, :condition),
     s(:lvar, :then_val), <-- then clause
     s(:lvar, :else_val)))

[Validate]