Class: Prism::DefNode

Inherits:
PrismNode
  • Object
show all
Defined in:
lib/prism/node.rb,
ext/prism/api_node.c

Overview

Represents a method definition.

def method
end
^^^^^^^^^^

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(name, name_loc, receiver, parameters, body, locals, locals_body_index, def_keyword_loc, operator_loc, lparen_loc, rparen_loc, equal_loc, end_keyword_loc, location) ⇒ DefNode

def initialize: (name: Symbol, name_loc: Location, receiver: Node?, parameters: ParametersNode?, body: Node?, locals: Array, locals_body_index: Integer, def_keyword_loc: Location, operator_loc: Location?, lparen_loc: Location?, rparen_loc: Location?, equal_loc: Location?, end_keyword_loc: Location?, location: Location) -> void



5278
5279
5280
5281
5282
5283
5284
5285
5286
5287
5288
5289
5290
5291
5292
5293
 
# File 'lib/prism/node.rb', line 5278

def initialize(name, name_loc, receiver, parameters, body, locals, locals_body_index, def_keyword_loc, operator_loc, lparen_loc, rparen_loc, equal_loc, end_keyword_loc, location)
  @name = name
  @name_loc = name_loc
  @receiver = receiver
  @parameters = parameters
  @body = body
  @locals = locals
  @locals_body_index = locals_body_index
  @def_keyword_loc = def_keyword_loc
  @operator_loc = operator_loc
  @lparen_loc = lparen_loc
  @rparen_loc = rparen_loc
  @equal_loc = equal_loc
  @end_keyword_loc = end_keyword_loc
  @location = location
end

Instance Attribute Details

#body ⇒ Object (readonly)

attr_reader body: Node?



5251
5252
5253
 
# File 'lib/prism/node.rb', line 5251

def body
  @body
end

#def_keyword_loc ⇒ Object (readonly)

attr_reader def_keyword_loc: Location



5260
5261
5262
 
# File 'lib/prism/node.rb', line 5260

def def_keyword_loc
  @def_keyword_loc
end

#end_keyword_loc ⇒ Object (readonly)

attr_reader end_keyword_loc: Location?



5275
5276
5277
 
# File 'lib/prism/node.rb', line 5275

def end_keyword_loc
  @end_keyword_loc
end

#equal_loc ⇒ Object (readonly)

attr_reader equal_loc: Location?



5272
5273
5274
 
# File 'lib/prism/node.rb', line 5272

def equal_loc
  @equal_loc
end

#locals ⇒ Object (readonly)

attr_reader locals: Array



5254
5255
5256
 
# File 'lib/prism/node.rb', line 5254

def locals
  @locals
end

#locals_body_index ⇒ Object (readonly)

attr_reader locals_body_index: Integer



5257
5258
5259
 
# File 'lib/prism/node.rb', line 5257

def locals_body_index
  @locals_body_index
end

#lparen_loc ⇒ Object (readonly)

attr_reader lparen_loc: Location?



5266
5267
5268
 
# File 'lib/prism/node.rb', line 5266

def lparen_loc
  @lparen_loc
end

#name ⇒ Object (readonly)

attr_reader name: Symbol



5239
5240
5241
 
# File 'lib/prism/node.rb', line 5239

def name
  @name
end

#name_loc ⇒ Object (readonly)

attr_reader name_loc: Location



5242
5243
5244
 
# File 'lib/prism/node.rb', line 5242

def name_loc
  @name_loc
end

#operator_loc ⇒ Object (readonly)

attr_reader operator_loc: Location?



5263
5264
5265
 
# File 'lib/prism/node.rb', line 5263

def operator_loc
  @operator_loc
end

#parameters ⇒ Object (readonly)

attr_reader parameters: ParametersNode?



5248
5249
5250
 
# File 'lib/prism/node.rb', line 5248

def parameters
  @parameters
end

#receiver ⇒ Object (readonly)

attr_reader receiver: Node?



5245
5246
5247
 
# File 'lib/prism/node.rb', line 5245

def receiver
  @receiver
end

#rparen_loc ⇒ Object (readonly)

attr_reader rparen_loc: Location?



5269
5270
5271
 
# File 'lib/prism/node.rb', line 5269

def rparen_loc
  @rparen_loc
end

Class Method Details

.type ⇒ Object

Similar to #type, this method returns a symbol that you can use for splitting on the type of the node without having to do a long === chain. Note that like #type, it will still be slower than using == for a single class, but should be faster in a case statement or an array comparison.

def self.type: () -> Symbol



5435
5436
5437
 
# File 'lib/prism/node.rb', line 5435

def self.type
  :def_node
end

Instance Method Details

#accept(visitor) ⇒ Object

def accept: (visitor: Visitor) -> void



5296
5297
5298
 
# File 'lib/prism/node.rb', line 5296

def accept(visitor)
  visitor.visit_def_node(self)
end

#child_nodes ⇒ Object Also known as: deconstruct

def child_nodes: () -> Array[nil | Node]



5301
5302
5303
 
# File 'lib/prism/node.rb', line 5301

def child_nodes
  [receiver, parameters, body]
end

#comment_targets ⇒ Object

def comment_targets: () -> Array[Node | Location]



5315
5316
5317
 
# File 'lib/prism/node.rb', line 5315

def comment_targets
  [name_loc, *receiver, *parameters, *body, def_keyword_loc, *operator_loc, *lparen_loc, *rparen_loc, *equal_loc, *end_keyword_loc]
end

#compact_child_nodes ⇒ Object

def compact_child_nodes: () -> Array



5306
5307
5308
5309
5310
5311
5312
 
# File 'lib/prism/node.rb', line 5306

def compact_child_nodes
  compact = []
  compact << receiver if receiver
  compact << parameters if parameters
  compact << body if body
  compact
end

#copy(**params) ⇒ Object

def copy: (**params) -> DefNode



5320
5321
5322
5323
5324
5325
5326
5327
5328
5329
5330
5331
5332
5333
5334
5335
5336
5337
 
# File 'lib/prism/node.rb', line 5320

def copy(**params)
  DefNode.new(
    params.fetch(:name) { name },
    params.fetch(:name_loc) { name_loc },
    params.fetch(:receiver) { receiver },
    params.fetch(:parameters) { parameters },
    params.fetch(:body) { body },
    params.fetch(:locals) { locals },
    params.fetch(:locals_body_index) { locals_body_index },
    params.fetch(:def_keyword_loc) { def_keyword_loc },
    params.fetch(:operator_loc) { operator_loc },
    params.fetch(:lparen_loc) { lparen_loc },
    params.fetch(:rparen_loc) { rparen_loc },
    params.fetch(:equal_loc) { equal_loc },
    params.fetch(:end_keyword_loc) { end_keyword_loc },
    params.fetch(:location) { location },
  )
end

#deconstruct_keys(keys) ⇒ Object

def deconstruct_keys: (keys: Array) -> Hash[Symbol, nil | Node | Array | String | Token | Array | Location]



5343
5344
5345
 
# File 'lib/prism/node.rb', line 5343

def deconstruct_keys(keys)
  { name: name, name_loc: name_loc, receiver: receiver, parameters: parameters, body: body, locals: locals, locals_body_index: locals_body_index, def_keyword_loc: def_keyword_loc, operator_loc: operator_loc, lparen_loc: lparen_loc, rparen_loc: rparen_loc, equal_loc: equal_loc, end_keyword_loc: end_keyword_loc, location: location }
end

#def_keyword ⇒ Object

def def_keyword: () -> String



5348
5349
5350
 
# File 'lib/prism/node.rb', line 5348

def def_keyword
  def_keyword_loc.slice
end

#end_keyword ⇒ Object

def end_keyword: () -> String?



5373
5374
5375
 
# File 'lib/prism/node.rb', line 5373

def end_keyword
  end_keyword_loc&.slice
end

#equal ⇒ Object

def equal: () -> String?



5368
5369
5370
 
# File 'lib/prism/node.rb', line 5368

def equal
  equal_loc&.slice
end

#inspect(inspector = NodeInspector.new) ⇒ Object

def inspect(inspector: NodeInspector) -> String



5378
5379
5380
5381
5382
5383
5384
5385
5386
5387
5388
5389
5390
5391
5392
5393
5394
5395
5396
5397
5398
5399
5400
5401
5402
5403
5404
5405
5406
5407
5408
5409
 
# File 'lib/prism/node.rb', line 5378

def inspect(inspector = NodeInspector.new)
  inspector << inspector.header(self)
  inspector << "├── name: #{name.inspect}\n"
  inspector << "├── name_loc: #{inspector.location(name_loc)}\n"
  if (receiver = self.receiver).nil?
    inspector << "├── receiver: ∅\n"
  else
    inspector << "├── receiver:\n"
    inspector << receiver.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
  end
  if (parameters = self.parameters).nil?
    inspector << "├── parameters: ∅\n"
  else
    inspector << "├── parameters:\n"
    inspector << parameters.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
  end
  if (body = self.body).nil?
    inspector << "├── body: ∅\n"
  else
    inspector << "├── body:\n"
    inspector << body.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
  end
  inspector << "├── locals: #{locals.inspect}\n"
  inspector << "├── locals_body_index: #{locals_body_index.inspect}\n"
  inspector << "├── def_keyword_loc: #{inspector.location(def_keyword_loc)}\n"
  inspector << "├── operator_loc: #{inspector.location(operator_loc)}\n"
  inspector << "├── lparen_loc: #{inspector.location(lparen_loc)}\n"
  inspector << "├── rparen_loc: #{inspector.location(rparen_loc)}\n"
  inspector << "├── equal_loc: #{inspector.location(equal_loc)}\n"
  inspector << "└── end_keyword_loc: #{inspector.location(end_keyword_loc)}\n"
  inspector.to_str
end

#lparen ⇒ Object

def lparen: () -> String?



5358
5359
5360
 
# File 'lib/prism/node.rb', line 5358

def lparen
  lparen_loc&.slice
end

#operator ⇒ Object

def operator: () -> String?



5353
5354
5355
 
# File 'lib/prism/node.rb', line 5353

def operator
  operator_loc&.slice
end

#rparen ⇒ Object

def rparen: () -> String?



5363
5364
5365
 
# File 'lib/prism/node.rb', line 5363

def rparen
  rparen_loc&.slice
end

#type ⇒ Object

Sometimes you want to check an instance of a node against a list of classes to see what kind of behavior to perform. Usually this is done by calling ‘[cls1, cls2].include?(node.class)` or putting the node into a case statement and doing `case node; when cls1; when cls2; end`. Both of these approaches are relatively slow because of the constant lookups, method calls, and/or array allocations.

Instead, you can call #type, which will return to you a symbol that you can use for comparison. This is faster than the other approaches because it uses a single integer comparison, but also because if you’re on CRuby you can take advantage of the fact that case statements with all symbol keys will use a jump table.

def type: () -> Symbol



5425
5426
5427
 
# File 'lib/prism/node.rb', line 5425

def type
  :def_node
end