Class: Archruby::Ruby::TypeInference::Ruby::ProcessMethodBody

Inherits:
SexpInterpreter
  • Object
show all
Defined in:
lib/archruby/ruby/type_inference/ruby/process_method_body.rb

Instance Method Summary collapse

Constructor Details

#initialize(ast, local_scope) ⇒ ProcessMethodBody

Returns a new instance of ProcessMethodBody.



7
8
9
10
11
12
13
14
15
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 7

def initialize(ast, local_scope)
  super()
  @ast = ast
  @params = {}
  @current_dependency_class = []
  @current_dependency_class_name = nil
  @method_calls = []
  @local_scope = local_scope
end

Instance Method Details

#add_method_call(class_name, method_name, params = nil) ⇒ Object 



54
55
56
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 54

def add_method_call(class_name, method_name, params=nil)
  @method_calls << InternalMethodInvocation.new(class_name, method_name, params)
end

#build_full_name(const_name) ⇒ Object 



87
88
89
90
91
92
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 87

def build_full_name(const_name)
  @current_dependency_class.unshift(const_name)
  full_class_path = @current_dependency_class.join('::')
  @current_dependency_class = []
  full_class_path
end

#check_if_has_params(params) ⇒ Object 



44
45
46
47
48
49
50
51
52
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 44

def check_if_has_params(params)
  has_local_params = false
  params.each do |param|
    if param[0] == :lvar
      has_local_params = @local_scope.has_formal_parameter(param[1]) || @local_scope.has_local_params(param[1])
    end
  end
  has_local_params
end

#parse ⇒ Object 



17
18
19
20
21
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 17

def parse
  #binding.pry
  @ast.map! {|sub_tree| process(sub_tree)}
  @method_calls
end

#process_alias(exp) ⇒ Object 



377
378
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 377

def process_alias(exp)
end

#process_and(exp) ⇒ Object 



177
178
179
180
181
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 177

def process_and(exp)
  _, left_side, right_side = exp
  process(left_side)
  process(right_side)
end

#process_array(exp) ⇒ Object 



172
173
174
175
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 172

def process_array(exp)
  _, *args = exp
  args.map! {|sub_tree| process(sub_tree)}
end

#process_attrasgn(exp) ⇒ Object 



94
95
96
97
98
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 94

def process_attrasgn(exp)
  _, receiver, method_name, value = exp
  process(receiver)
  process(value)
end

#process_back_ref(exp) ⇒ Object 



370
371
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 370

def process_back_ref(exp)
end

#process_begin(exp) ⇒ Object 



380
381
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 380

def process_begin(exp)
end

#process_block(exp) ⇒ Object 



139
140
141
142
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 139

def process_block(exp)
  _, *args = exp
  args.map! { |subtree| process(subtree) }
end

#process_block_pass(exp) ⇒ Object 



315
316
317
318
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 315

def process_block_pass(exp)
  _, *args = exp
  args.map! {|sub_tree| process(sub_tree)}
end

#process_break(exp) ⇒ Object 



392
393
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 392

def process_break(exp)
end

#process_call(exp) ⇒ Object 



23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 23

def process_call(exp)
  _, receiver, method_name, *params = exp
  if receiver && receiver[0] == :lvar && receiver[1].class == Symbol
    type = @local_scope.var_type(receiver[1])
    parsed_params = ProcessMethodParams.new(params, @local_scope).parse
    add_method_call(type, method_name, parsed_params)
  elsif !receiver.nil?
    process(receiver)
    parsed_params = nil
    if check_if_has_params(params)
      parsed_params = ProcessMethodParams.new(params, @local_scope).parse
    end
    add_method_call(@current_dependency_class_name, method_name, parsed_params)
    #@current_dependency_class_name = nil
  end
end

#process_case(exp) ⇒ Object 



272
273
274
275
276
277
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 272

def process_case(exp)
  _, condition, when_part, ensure_part = exp
  process(condition)
  process(when_part)
  process(ensure_part)
end

#process_colon2(exp) ⇒ Object 



81
82
83
84
85
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 81

def process_colon2(exp)
  _, first_part, last_part = exp
  @current_dependency_class.unshift(last_part)
  process(first_part)
end

#process_colon3(exp) ⇒ Object 



76
77
78
79
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 76

def process_colon3(exp)
  _, constant_name = exp
  @current_dependency_class_name = build_full_name("::#{constant_name}")
end

#process_const(exp) ⇒ Object 



67
68
69
70
71
72
73
74
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 67

def process_const(exp)
  _, const_name = exp
  if !@current_dependency_class.empty?
    @current_dependency_class_name = build_full_name(const_name)
  else
    @current_dependency_class_name = const_name.to_s
  end
end

#process_cvar(exp) ⇒ Object 



373
374
375
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 373

def process_cvar(exp)
  # class variable
end

#process_cvasgn(exp) ⇒ Object 



298
299
300
301
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 298

def process_cvasgn(exp)
  _, class_var_name, *value = exp
  value.map! {|sub_tree| process(sub_tree)}
end

#process_cvdecl(exp) ⇒ Object 



365
366
367
368
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 365

def process_cvdecl(exp)
  _, instance_classvar_name, *value = exp
  value.map! {|sub_tree| process(sub_tree)}
end

#process_defined(exp) ⇒ Object 



360
361
362
363
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 360

def process_defined(exp)
  _, *args = exp
  args.map! {|sub_tree| process(sub_tree)}
end

#process_defn(exp) ⇒ Object 



328
329
330
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 328

def process_defn(exp)
  #estudar esse caso para ver se vamos quer pegar isso
end

#process_defs(exp) ⇒ Object 



40
41
42
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 40

def process_defs(exp)
  #estudar esse caso -> acontece no rails em activemodel
end

#process_dot2(exp) ⇒ Object 



309
310
311
312
313
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 309

def process_dot2(exp)
  _, left, right = exp
  process(left)
  process(right)
end

#process_dot3(exp) ⇒ Object 



303
304
305
306
307
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 303

def process_dot3(exp)
  _, left, right = exp
  process(left)
  process(right)
end

#process_dregx(exp) ⇒ Object 



323
324
325
326
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 323

def process_dregx(exp)
  _, str, *args = exp
  args.map! {|sub_tree| process(sub_tree) if sub_tree.class == Sexp}
end

#process_dregx_once(exp) ⇒ Object 



194
195
196
197
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 194

def process_dregx_once(exp)
  _, start, *args = exp
  args.map! {|sub_tree| process(sub_tree)}
end

#process_dstr(exp) ⇒ Object 



189
190
191
192
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 189

def process_dstr(exp)
  _, start, *args = exp
  args.map! {|sub_tree| process(sub_tree)}
end

#process_dsym(exp) ⇒ Object 



134
135
136
137
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 134

def process_dsym(exp)
  _, str, *args = exp
  args.map! {|sub_tree| process(sub_tree)}
end

#process_dxstr(exp) ⇒ Object 



209
210
211
212
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 209

def process_dxstr(exp)
  _, str, *args = exp
  args.map! {|sub_tree| process(sub_tree)}
end

#process_ensure(exp) ⇒ Object 



245
246
247
248
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 245

def process_ensure(exp)
  _, *args = exp
  args.map! {|sub_tree| process(sub_tree)}
end

#process_evstr(exp) ⇒ Object 



199
200
201
202
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 199

def process_evstr(exp)
  _, *args = exp
  args.map! {|sub_tree| process(sub_tree)}
end

#process_false(exp) ⇒ Object 



419
420
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 419

def process_false(exp)
end

#process_for(exp) ⇒ Object 



279
280
281
282
283
284
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 279

def process_for(exp)
  _, x, y, body = exp
  process(x)
  process(y)
  process(body)
end

#process_gasgn(exp) ⇒ Object 



345
346
347
348
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 345

def process_gasgn(exp)
  _, global_var_name, *value = exp
  value.map! {|sub_tree| process(sub_tree)}
end

#process_gvar(exp) ⇒ Object 



401
402
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 401

def process_gvar(exp)
end

#process_hash(exp) ⇒ Object 



144
145
146
147
148
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 144

def process_hash(exp)
  _, key, value = exp
  process(key)
  process(value)
end

#process_iasgn(exp) ⇒ Object 



100
101
102
103
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 100

def process_iasgn(exp)
  _, instance_varialbe_name, *value = exp
  value.map! { |subtree| process(subtree) }
end

#process_if(exp) ⇒ Object 



127
128
129
130
131
132
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 127

def process_if(exp)
  _, condition, true_body, else_body = exp
  process(condition)
  process(true_body)
  process(else_body)
end

#process_iter(exp) ⇒ Object 



121
122
123
124
125
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 121

def process_iter(exp)
  _, first_part, second_part, *body = exp
  process(first_part)
  body.map! {|sub_tree| process(sub_tree)}
end

#process_ivar(exp) ⇒ Object 



214
215
216
217
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 214

def process_ivar(exp)
  _, var_name, *args = exp
  args.map! {|sub_tree| process(sub_tree)}
end

#process_lasgn(exp) ⇒ Object 



58
59
60
61
62
63
64
65
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 58

def process_lasgn(exp)
  _, variable_name, *args = exp
  args.map! { |subtree| process(subtree) }
  if @current_dependency_class_name
    @local_scope.add_variable(variable_name, @current_dependency_class_name)
  end
  @current_dependency_class_name = nil
end

#process_lit(exp) ⇒ Object 



410
411
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 410

def process_lit(exp)
end

#process_lvar(exp) ⇒ Object 



413
414
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 413

def process_lvar(exp)
end

#process_masgn(exp) ⇒ Object 



332
333
334
335
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 332

def process_masgn(exp)
  _, *args = exp
  args.map! {|sub_tree| process(sub_tree)}
end

#process_match2(exp) ⇒ Object 



219
220
221
222
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 219

def process_match2(exp)
  _, rec, *args = exp
  args.map! {|sub_tree| process(sub_tree)}
end

#process_match3(exp) ⇒ Object 



109
110
111
112
113
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 109

def process_match3(exp)
  _, left_side, right_side = exp
  process(left_side)
  process(right_side)
end

#process_next(exp) ⇒ Object 



395
396
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 395

def process_next(exp)
end

#process_nil(exp) ⇒ Object 



404
405
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 404

def process_nil(exp)
end

#process_not(exp) ⇒ Object 



355
356
357
358
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 355

def process_not(exp)
  _, *args = exp
  args.map! {|sub_tree| process(sub_tree)}
end

#process_nth_ref(exp) ⇒ Object 



389
390
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 389

def process_nth_ref(exp)
end

#process_op_asgn1(exp) ⇒ Object 



105
106
107
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 105

def process_op_asgn1(exp)
  process(exp.last)
end

#process_op_asgn2(exp) ⇒ Object 



115
116
117
118
119
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 115

def process_op_asgn2(exp)
  _, receiver, method, met, last = exp
  process(receiver)
  process(last)
end

#process_op_asgn_and(exp) ⇒ Object 



240
241
242
243
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 240

def process_op_asgn_and(exp)
  _, *args = exp
  args.map! {|sub_tree| process(sub_tree)}
end

#process_op_asgn_or(exp) ⇒ Object 



235
236
237
238
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 235

def process_op_asgn_or(exp)
  _, *args = exp
  args.map! {|sub_tree| process(sub_tree)}
end

#process_or(exp) ⇒ Object 



183
184
185
186
187
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 183

def process_or(exp)
  _, left_side, right_side = exp
  process(left_side)
  process(right_side)
end

#process_redo(exp) ⇒ Object 



337
338
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 337

def process_redo(exp)
end

#process_resbody(exp) ⇒ Object 



166
167
168
169
170
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 166

def process_resbody(exp)
  _, class_to_rescue, *body = exp
  process(class_to_rescue)
  body.map! {|sub_tree| process(sub_tree)}
end

#process_rescue(exp) ⇒ Object 



155
156
157
158
159
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 155

def process_rescue(exp)
  _, normal, *rescue_body = exp
  process(normal)
  rescue_body.map! {|sub_tree| process(sub_tree)}
end

#process_retry(exp) ⇒ Object 



320
321
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 320

def process_retry(exp)
end

#process_return(exp) ⇒ Object 



161
162
163
164
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 161

def process_return(exp)
  _, *value = exp
  value.map! {|sub_tree| process(sub_tree)}
end

#process_sclass(exp) ⇒ Object 



350
351
352
353
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 350

def process_sclass(exp)
  _, singleton_class, *body = exp
  body.map! {|sub_tree| process(sub_tree)}
end

#process_self(exp) ⇒ Object 



383
384
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 383

def process_self(exp)
end

#process_splat(exp) ⇒ Object 



267
268
269
270
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 267

def process_splat(exp)
  _, *args = exp
  args.map! {|sub_tree| process(sub_tree)}
end

#process_str(exp) ⇒ Object 



398
399
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 398

def process_str(exp)
end

#process_super(exp) ⇒ Object 



150
151
152
153
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 150

def process_super(exp)
  _, *args = exp
  args.map! {|sub_tree| process(sub_tree)}
end

#process_svalue(exp) ⇒ Object 



230
231
232
233
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 230

def process_svalue(exp)
  _, *args = exp
  args.map! {|sub_tree| process(sub_tree)}
end

#process_to_ary(exp) ⇒ Object 



340
341
342
343
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 340

def process_to_ary(exp)
  _, *args = exp
  args.map! {|sub_tree| process(sub_tree)}
end

#process_true(exp) ⇒ Object 



416
417
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 416

def process_true(exp)
end

#process_until(exp) ⇒ Object 



256
257
258
259
260
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 256

def process_until(exp)
  _, condition, body, *args = exp
  process(condition)
  process(body)
end

#process_when(exp) ⇒ Object 



286
287
288
289
290
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 286

def process_when(exp)
  _, condition, body = exp
  process(condition)
  process(body)
end

#process_while(exp) ⇒ Object 



250
251
252
253
254
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 250

def process_while(exp)
  _, condition, body = exp
  process(condition)
  process(body)
end

#process_xstr(exp) ⇒ Object 



386
387
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 386

def process_xstr(exp)
end

#process_yield(exp) ⇒ Object 



262
263
264
265
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 262

def process_yield(exp)
  _, *args = exp
  args.map! {|sub_tree| process(sub_tree)}
end

#process_zsuper(exp) ⇒ Object 



407
408
 
# File 'lib/archruby/ruby/type_inference/ruby/process_method_body.rb', line 407

def process_zsuper(exp)
end