Class: Solargraph::Pin::Base

Inherits:
Object
  • Object
show all
Includes:
Logging, Common, Conversions, Documenting
Defined in:
lib/solargraph/pin/base.rb

Overview

The base class for map pins.

Direct Known Subclasses

BaseVariable, Closure, Keyword, ProxyType, Reference, Symbol, Until, While

Constant Summary

Constants included from Logging

Logging::DEFAULT_LOG_LEVEL, Logging::LOG_LEVELS

Instance Attribute Summary collapse

Attributes included from Common

#context

Instance Method Summary collapse

Methods included from Logging

logger

Methods included from Documenting

#documentation, normalize_indentation, strip_html_comments

Methods included from Conversions

#completion_item, #detail, #link_documentation, #reset_conversions, #resolve_completion_item, #signature_help, #text_documentation

Methods included from Common

#binder, #namespace

Constructor Details

#initialize(location: nil, type_location: nil, closure: nil, source: nil, name: '', comments: '', docstring: nil, directives: nil, combine_priority: nil) ⇒ Base

Returns a new instance of Base.

Parameters:

  • location (Solargraph::Location, nil) (defaults to: nil)
  • type_location (Solargraph::Location, nil) (defaults to: nil)
  • closure (Solargraph::Pin::Closure, nil) (defaults to: nil)
  • name (String) (defaults to: '')
  • comments (String) (defaults to: '')
  • source (Symbol, nil) (defaults to: nil)
  • docstring (YARD::Docstring, nil) (defaults to: nil)
  • directives (::Array<YARD::Tags::Directive>, nil) (defaults to: nil)
  • combine_priority (::Numeric, nil) (defaults to: nil) —

    See attr_reader for combine_priority



49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
 
# File 'lib/solargraph/pin/base.rb', line 49

def initialize location: nil, type_location: nil, closure: nil, source: nil, name: '', comments: '', docstring: nil, directives: nil, combine_priority: nil
  @location = location
  @type_location = type_location
  @closure = closure
  @name = name
  @comments = comments
  @source = source
  @identity = nil
  @docstring = docstring
  @directives = directives
  @combine_priority = combine_priority

  assert_source_provided
  assert_location_provided
end

Instance Attribute Details

#code_object ⇒ YARD::CodeObjects::Base (readonly)

Returns:

  • (YARD::CodeObjects::Base) 


14
15
16
 
# File 'lib/solargraph/pin/base.rb', line 14

def code_object
  @code_object
end

#combine_priority ⇒ Object (readonly)

Returns the value of attribute combine_priority.



34
35
36
 
# File 'lib/solargraph/pin/base.rb', line 34

def combine_priority
  @combine_priority
end

#directives ⇒ ::Array<YARD::Tags::Directive>

Returns:

  • (::Array<YARD::Tags::Directive>) 


488
489
490
491
 
# File 'lib/solargraph/pin/base.rb', line 488

def directives
  parse_comments unless @directives
  @directives
end

#docstring ⇒ YARD::Docstring

Returns:

  • (YARD::Docstring) 


482
483
484
485
 
# File 'lib/solargraph/pin/base.rb', line 482

def docstring
  parse_comments unless @docstring
  @docstring ||= Solargraph::Source.parse_docstring('').to_docstring
end

#location ⇒ Solargraph::Location? (readonly)

Returns:



17
18
19
 
# File 'lib/solargraph/pin/base.rb', line 17

def location
  @location
end

#name ⇒ String (readonly)

Returns:

  • (String) 


23
24
25
 
# File 'lib/solargraph/pin/base.rb', line 23

def name
  @name
end

#path ⇒ String (readonly)

Returns:

  • (String) 


26
27
28
 
# File 'lib/solargraph/pin/base.rb', line 26

def path
  @path
end

#return_type ⇒ ComplexType

The pin’s return type.

Returns:



477
478
479
 
# File 'lib/solargraph/pin/base.rb', line 477

def return_type
  @return_type ||= ComplexType::UNDEFINED
end

#source ⇒ ::Symbol

Returns:

  • (::Symbol) 


29
30
31
 
# File 'lib/solargraph/pin/base.rb', line 29

def source
  @source
end

#type_location ⇒ Solargraph::Location? (readonly)

Returns:



20
21
22
 
# File 'lib/solargraph/pin/base.rb', line 20

def type_location
  @type_location
end

Instance Method Details

#==(other) ⇒ Object

Pin equality is determined using the #nearly? method and also requiring both pins to have the same location.

Parameters:

  • other (Object) 


468
469
470
471
472
 
# File 'lib/solargraph/pin/base.rb', line 468

def == other
  return false unless nearly? other
  # @sg-ignore Should add more explicit type check on other
  comments == other.comments && location == other.location
end

#all_location_text ⇒ String

Returns:

  • (String) 


637
638
639
640
641
642
643
644
645
646
647
 
# File 'lib/solargraph/pin/base.rb', line 637

def all_location_text
  if location.nil? && type_location.nil?
    ''
  elsif !location.nil? && type_location.nil?
    " at #{location.inspect})"
  elsif !type_location.nil? && location.nil?
    " at #{type_location.inspect})"
  else
    " at (#{location.inspect} and #{type_location.inspect})"
  end
end

#all_rooted? ⇒ Boolean

Returns:

  • (Boolean) 


407
408
409
 
# File 'lib/solargraph/pin/base.rb', line 407

def all_rooted?
  !return_type || return_type.all_rooted?
end

#assert_location_provided ⇒ void

This method returns an undefined value.



66
67
68
69
70
 
# File 'lib/solargraph/pin/base.rb', line 66

def assert_location_provided
  return unless best_location.nil? && %i[yardoc source rbs].include?(source)

  Solargraph.assert_or_log(:best_location, "Neither location nor type_location provided - #{path} #{source} #{self.class}")
end

#assert_same(other, attr) ⇒ undefined

@sg-ignore

Parameters:

  • other (self)
  • attr (::Symbol)

Returns:

  • (undefined) 


311
312
313
314
315
316
317
318
319
 
# File 'lib/solargraph/pin/base.rb', line 311

def assert_same(other, attr)
  return false if other.nil?
  val1 = send(attr)
  val2 = other.send(attr)
  return val1 if val1 == val2
  Solargraph.assert_or_log("combine_with_#{attr}".to_sym,
                           "Inconsistent #{attr.inspect} values between \nself =#{inspect} and \nother=#{other.inspect}:\n\n self.#{attr} = #{val1.inspect}\nother.#{attr} = #{val2.inspect}")
  val1
end

#assert_same_array_content(other, attr, &block) ⇒ void

TODO:

strong typechecking should complain when there are no block-related tags

This method returns an undefined value.

Parameters:

  • other (self)
  • attr (::Symbol) 


270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
 
# File 'lib/solargraph/pin/base.rb', line 270

def assert_same_array_content(other, attr, &block)
  arr1 = send(attr)
  raise "Expected #{attr} on #{self} to be an Enumerable, got #{arr1.class}" unless arr1.is_a?(::Enumerable)
  # @type arr1 [::Enumerable]
  arr2 = other.send(attr)
  raise "Expected #{attr} on #{other} to be an Enumerable, got #{arr2.class}" unless arr2.is_a?(::Enumerable)
  # @type arr2 [::Enumerable]

  # @type [undefined]
  values1 = arr1.map(&block)
  # @type [undefined]
  values2 = arr2.map(&block)
  # @sg-ignore
  return arr1 if values1 == values2
  Solargraph.assert_or_log("combine_with_#{attr}".to_sym,
                           "Inconsistent #{attr.inspect} values between \nself =#{inspect} and \nother=#{other.inspect}:\n\n self values = #{values1}\nother values =#{attr} = #{values2}")
  arr1
end

#assert_same_count(other, attr) ⇒ ::Enumerable

Parameters:

  • other (self)
  • attr (::Symbol)

Returns:

  • (::Enumerable) 


293
294
295
296
297
298
299
300
301
302
303
304
 
# File 'lib/solargraph/pin/base.rb', line 293

def assert_same_count(other, attr)
  # @type [::Enumerable]
  arr1 = self.send(attr)
  raise "Expected #{attr} on #{self} to be an Enumerable, got #{arr1.class}" unless arr1.is_a?(::Enumerable)
  # @type [::Enumerable]
  arr2 = other.send(attr)
  raise "Expected #{attr} on #{other} to be an Enumerable, got #{arr2.class}" unless arr2.is_a?(::Enumerable)
  return arr1 if arr1.count == arr2.count
  Solargraph.assert_or_log("combine_with_#{attr}".to_sym,
                           "Inconsistent #{attr.inspect} count value between \nself =#{inspect} and \nother=#{other.inspect}:\n\n self.#{attr} = #{arr1.inspect}\nother.#{attr} = #{arr2.inspect}")
  arr1
end

#assert_same_macros(other) ⇒ void

This method returns an undefined value.

Parameters:

  • other (self) 


259
260
261
262
263
264
 
# File 'lib/solargraph/pin/base.rb', line 259

def assert_same_macros(other)
  return unless self.source == :yardoc && other.source == :yardoc
  assert_same_count(other, :macros)
  # @param [YARD::Tags::MacroDirective]
  assert_same_array_content(other, :macros) { |macro| macro.tag.name }
end

#assert_source_provided ⇒ void

This method returns an undefined value.



369
370
371
 
# File 'lib/solargraph/pin/base.rb', line 369

def assert_source_provided
  Solargraph.assert_or_log(:source, "source not provided - #{@path} #{@source} #{self.class}") if source.nil?
end

#best_location ⇒ Location?

Returns:



444
445
446
 
# File 'lib/solargraph/pin/base.rb', line 444

def best_location
  location || type_location
end

#choose(other, attr) ⇒ Object?

when choices are arbitrary, make sure the choice is consistent

Parameters:

Returns:

  • (Object, nil) 


217
218
219
220
221
222
223
224
225
 
# File 'lib/solargraph/pin/base.rb', line 217

def choose(other, attr)
  results = [self, other].map(&attr).compact
  # true and false are different classes and can't be sorted
  return true if results.any? { |r| r == true || r == false }
  results.min
rescue
  STDERR.puts("Problem handling #{attr} for \n#{self.inspect}\n and \n#{other.inspect}\n\n#{self.send(attr).inspect} vs #{other.send(attr).inspect}")
  raise
end

#choose_longer(other, attr) ⇒ undefined

@sg-ignore

Parameters:

  • other (self)
  • attr (::Symbol)

Returns:

  • (undefined) 


132
133
134
135
136
137
138
139
140
 
# File 'lib/solargraph/pin/base.rb', line 132

def choose_longer(other, attr)
  # @type [undefined]
  val1 = send(attr)
  # @type [undefined]
  val2 = other.send(attr)
  return val1 if val1 == val2
  return val2 if val1.nil?
  val1.length > val2.length ? val1 : val2
end

#choose_node(other, attr) ⇒ undefined

@sg-ignore

Parameters:

  • other (self)
  • attr (::Symbol)

Returns:

  • (undefined) 


231
232
233
234
235
236
237
 
# File 'lib/solargraph/pin/base.rb', line 231

def choose_node(other, attr)
  if other.object_id < attr.object_id
    other.send(attr)
  else
    send(attr)
  end
end

#choose_pin_attr(other, attr) ⇒ undefined

@sg-ignore Missing @return tag for Solargraph::Pin::Base#choose_pin_attr

Parameters:

  • other (self)
  • attr (::Symbol)

Returns:

  • (undefined) 


344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
 
# File 'lib/solargraph/pin/base.rb', line 344

def choose_pin_attr(other, attr)
  # @type [Pin::Base, nil]
  val1 = send(attr)
  # @type [Pin::Base, nil]
  val2 = other.send(attr)
  if val1.class != val2.class
    # :nocov:
    Solargraph.assert_or_log("combine_with_#{attr}_class".to_sym,
                             "Inconsistent #{attr.inspect} class values between \nself =#{inspect} and \nother=#{other.inspect}:\n\n self.#{attr} = #{val1.inspect}\nother.#{attr} = #{val2.inspect}")
    return val1
    # :nocov:
  end
  # arbitrary way of choosing a pin
  [val1, val2].compact.max_by do |closure|
    [
      # maximize number of gates, as types in other combined pins may
      # depend on those gates
      closure.gates.length,
      # use basename so that results don't vary system to system
      File.basename(closure.best_location.to_s)
    ]
  end
end

#choose_pin_attr_with_same_name(other, attr) ⇒ undefined

@sg-ignore

Parameters:

  • other (self)
  • attr (::Symbol)

Returns:

  • (undefined) 


325
326
327
328
329
330
331
332
333
334
335
336
337
 
# File 'lib/solargraph/pin/base.rb', line 325

def choose_pin_attr_with_same_name(other, attr)
  # @type [Pin::Base, nil]
  val1 = send(attr)
  # @type [Pin::Base, nil]
  val2 = other.send(attr)
  raise "Expected pin for #{attr} on\n#{self.inspect},\ngot #{val1.inspect}" unless val1.nil? || val1.is_a?(Pin::Base)
  raise "Expected pin for #{attr} on\n#{other.inspect},\ngot #{val2.inspect}" unless val2.nil? || val2.is_a?(Pin::Base)
  if val1&.name != val2&.name
    Solargraph.assert_or_log("combine_with_#{attr}_name".to_sym,
                             "Inconsistent #{attr.inspect} name values between \nself =#{inspect} and \nother=#{other.inspect}:\n\n self.#{attr} = #{val1.inspect}\nother.#{attr} = #{val2.inspect}")
  end
  choose_pin_attr(other, attr)
end

#choose_priority(other) ⇒ self?

Returns either the pin chosen based on priority or nil A nil return means that the combination process must proceed

Parameters:

  • other (self)

Returns:

  • (self, nil) —

    Returns either the pin chosen based on priority or nil A nil return means that the combination process must proceed



112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
 
# File 'lib/solargraph/pin/base.rb', line 112

def choose_priority(other)
  if combine_priority.nil? && !other.combine_priority.nil?
    return other
  elsif other.combine_priority.nil? && !combine_priority.nil?
    return self
  elsif !combine_priority.nil? && !other.combine_priority.nil?
    if combine_priority > other.combine_priority
      return self
    elsif combine_priority < other.combine_priority
      return other
    end
  end

  nil
end

#closure ⇒ Pin::Closure?

Returns:



73
74
75
76
77
 
# File 'lib/solargraph/pin/base.rb', line 73

def closure
  Solargraph.assert_or_log(:closure, "Closure not set on #{self.class} #{name.inspect} from #{source.inspect}") unless @closure
  # @type [Pin::Closure, nil]
  @closure
end

#combine_directives(other) ⇒ ::Array<YARD::Tags::Directive>?

Parameters:

  • other (self)

Returns:

  • (::Array<YARD::Tags::Directive>, nil) 


144
145
146
147
148
 
# File 'lib/solargraph/pin/base.rb', line 144

def combine_directives(other)
  return self.directives if other.directives.empty?
  return other.directives if directives.empty?
  [directives + other.directives].uniq
end

#combine_name(other) ⇒ String

Parameters:

  • other (self)

Returns:

  • (String) 


152
153
154
155
156
157
158
 
# File 'lib/solargraph/pin/base.rb', line 152

def combine_name(other)
  if needs_consistent_name? || other.needs_consistent_name?
    assert_same(other, :name)
  else
    choose(other, :name)
  end
end

#combine_return_type(other) ⇒ ComplexType

Parameters:

  • other (self)

Returns:



187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
 
# File 'lib/solargraph/pin/base.rb', line 187

def combine_return_type(other)
  if return_type.undefined?
    other.return_type
  elsif other.return_type.undefined?
    return_type
  elsif dodgy_return_type_source? && !other.dodgy_return_type_source?
    other.return_type
  elsif other.dodgy_return_type_source? && !dodgy_return_type_source?
    return_type
  else
    all_items = return_type.items + other.return_type.items
    if all_items.any? { |item| item.selfy? } && all_items.any? { |item| item.rooted_tag == context.reduce_class_type.rooted_tag }
      # assume this was a declaration that should have said 'self'
      all_items.delete_if { |item| item.rooted_tag == context.reduce_class_type.rooted_tag }
    end
    ComplexType.new(all_items)
  end
end

#combine_with(other, attrs = {}) ⇒ self

Parameters:

  • other (self)
  • attrs (Hash{::Symbol => Object}) (defaults to: {})

Returns:

  • (self) 


83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
 
# File 'lib/solargraph/pin/base.rb', line 83

def combine_with(other, attrs={})
  raise "tried to combine #{other.class} with #{self.class}" unless other.class == self.class
  priority_choice = choose_priority(other)
  return priority_choice unless priority_choice.nil?

  type_location = choose(other, :type_location)
  location = choose(other, :location)
  combined_name = combine_name(other)
  new_attrs = {
    location: location,
    type_location: type_location,
    name: combined_name,
    closure: choose_pin_attr_with_same_name(other, :closure),
    comments: choose_longer(other, :comments),
    source: :combined,
    docstring: choose(other, :docstring),
    directives: combine_directives(other),
    combine_priority: combine_priority
  }.merge(attrs)
  assert_same_macros(other)
  logger.debug { "Base#combine_with(path=#{path}) - other.comments=#{other.comments.inspect}, self.comments = #{self.comments}" }
  out = self.class.new(**new_attrs)
  out.reset_generated!
  out
end

#comments ⇒ String

Returns:

  • (String) 


374
375
376
 
# File 'lib/solargraph/pin/base.rb', line 374

def comments
  @comments ||= ''
end

#completion_item_kind ⇒ Integer

Returns:

  • (Integer) 


425
426
427
 
# File 'lib/solargraph/pin/base.rb', line 425

def completion_item_kind
  LanguageServer::CompletionItemKinds::KEYWORD
end

#deprecated? ⇒ Boolean

Returns:

  • (Boolean) 


512
513
514
 
# File 'lib/solargraph/pin/base.rb', line 512

def deprecated?
  @deprecated ||= docstring.has_tag?('deprecated')
end

#desc ⇒ String

Returns:

  • (String) 


627
628
629
 
# File 'lib/solargraph/pin/base.rb', line 627

def desc
  "[#{inner_desc}]"
end

#dodgy_return_type_source? ⇒ Boolean

Returns:

  • (Boolean) 


206
207
208
209
 
# File 'lib/solargraph/pin/base.rb', line 206

def dodgy_return_type_source?
  # uses a lot of 'Object' instead of 'self'
  location&.filename&.include?('core_ext/object/')
end

#erase_generics(generics_to_erase) ⇒ self

Parameters:

  • generics_to_erase (::Array<String>)

Returns:

  • (self) 


413
414
415
416
 
# File 'lib/solargraph/pin/base.rb', line 413

def erase_generics(generics_to_erase)
  return self if generics_to_erase.empty?
  transform_types { |t| t.erase_generics(generics_to_erase) }
end

#filename ⇒ String?

Returns:

  • (String, nil) 


419
420
421
422
 
# File 'lib/solargraph/pin/base.rb', line 419

def filename
  return nil if location.nil?
  location.filename
end

#gates ⇒ Array<String>

The namespaces available for resolving the current namespace. Each gate should be a fully qualified namespace or the root namespace (i.e., an empty string.)

Example: Given the name ‘Bar’ and the gates [‘Foo’, ”], the fully qualified namespace should be ‘Foo::Bar’ or ‘Bar’.

Returns:

  • (Array<String>) 


594
595
596
 
# File 'lib/solargraph/pin/base.rb', line 594

def gates
  @gates ||= closure&.gates || ['']
end

#identity ⇒ String

Deprecated.

Returns:

  • (String) 


582
583
584
 
# File 'lib/solargraph/pin/base.rb', line 582

def identity
  @identity ||= "#{closure&.path}|#{name}|#{location}"
end

#infer(api_map) ⇒ ComplexType

Deprecated.

Use #typify and/or #probe instead

Parameters:

Returns:



539
540
541
542
543
544
 
# File 'lib/solargraph/pin/base.rb', line 539

def infer api_map
  Solargraph::Logging.logger.warn "WARNING: Pin #infer methods are deprecated. Use #typify or #probe instead."
  type = typify(api_map)
  return type unless type.undefined?
  probe api_map
end

#inner_desc ⇒ String

Returns:

  • (String) 


620
621
622
623
624
 
# File 'lib/solargraph/pin/base.rb', line 620

def inner_desc
  closure_info = closure&.desc
  binder_info = binder&.desc
  "name=#{name.inspect} return_type=#{type_desc}, context=#{context.rooted_tags}, closure=#{closure_info}, binder=#{binder_info}"
end

#inspect ⇒ String

Returns:

  • (String) 


632
633
634
 
# File 'lib/solargraph/pin/base.rb', line 632

def inspect
  "#<#{self.class} `#{self.inner_desc}`#{all_location_text} via #{source.inspect}>"
end

#macros ⇒ ::Array<YARD::Tags::MacroDirective>

Returns:

  • (::Array<YARD::Tags::MacroDirective>) 


494
495
496
 
# File 'lib/solargraph/pin/base.rb', line 494

def macros
  @macros ||= collect_macros
end

#maybe_directives? ⇒ Boolean

Perform a quick check to see if this pin possibly includes YARD directives. This method does not require parsing the comments.

After the comments have been parsed, this method will return false if no directives were found, regardless of whether it previously appeared possible.

Returns:

  • (Boolean) 


506
507
508
509
 
# File 'lib/solargraph/pin/base.rb', line 506

def maybe_directives?
  return !@directives.empty? if defined?(@directives) && @directives
  @maybe_directives ||= comments.include?('@!')
end

#nearly?(other) ⇒ Boolean

True if the specified pin is a near match to this one. A near match indicates that the pins contain mostly the same data. Any differences between them should not have an impact on the API surface.

Parameters:

Returns:

  • (Boolean) 


454
455
456
457
458
459
460
461
462
 
# File 'lib/solargraph/pin/base.rb', line 454

def nearly? other
  self.class == other.class &&
    name == other.name &&
    (closure == other.closure || (closure && closure.nearly?(other.closure))) &&
    (comments == other.comments ||
      (((maybe_directives? == false && other.maybe_directives? == false) || compare_directives(directives, other.directives)) &&
      compare_docstring_tags(docstring, other.docstring))
    )
end

#needs_consistent_name? ⇒ Boolean

Returns:

  • (Boolean) 


176
177
178
 
# File 'lib/solargraph/pin/base.rb', line 176

def needs_consistent_name?
  true
end

#prefer_rbs_location(other, attr) ⇒ undefined

@sg-ignore

Parameters:

  • other (self)
  • attr (::Symbol)

Returns:

  • (undefined) 


243
244
245
246
247
248
249
250
251
 
# File 'lib/solargraph/pin/base.rb', line 243

def prefer_rbs_location(other, attr)
  if rbs_location? && !other.rbs_location?
    self.send(attr)
  elsif !rbs_location? && other.rbs_location?
    other.send(attr)
  else
    choose(other, attr)
  end
end

#presence_certain? ⇒ Boolean

Returns:

  • (Boolean) 


36
37
38
 
# File 'lib/solargraph/pin/base.rb', line 36

def presence_certain?
  true
end

#probe(api_map) ⇒ ComplexType

Infer the pin’s return type via static code analysis.

Parameters:

Returns:



532
533
534
 
# File 'lib/solargraph/pin/base.rb', line 532

def probe api_map
  typify api_map
end

#probed? ⇒ Boolean

Returns:

  • (Boolean) 


550
551
552
 
# File 'lib/solargraph/pin/base.rb', line 550

def probed?
  @probed ||= false
end

#proxied? ⇒ Boolean

Returns:

  • (Boolean) 


546
547
548
 
# File 'lib/solargraph/pin/base.rb', line 546

def proxied?
  @proxied ||= false
end

#proxy(return_type) ⇒ self

Return a proxy for this pin with the specified return type. Other than the return type and the #proxied? setting, the proxy should be a clone of the original.

Parameters:

Returns:

  • (self) 


573
574
575
576
577
578
 
# File 'lib/solargraph/pin/base.rb', line 573

def proxy return_type
  result = dup
  result.return_type = return_type
  result.proxied = true
  result
end

#rbs_location? ⇒ Boolean

Returns:

  • (Boolean) 


253
254
255
 
# File 'lib/solargraph/pin/base.rb', line 253

def rbs_location?
  type_location&.rbs?
end

#realize(api_map) ⇒ self

Parameters:

Returns:

  • (self) 


556
557
558
559
560
561
562
563
564
565
 
# File 'lib/solargraph/pin/base.rb', line 556

def realize api_map
  return self if return_type.defined?
  type = typify(api_map)
  return proxy(type) if type.defined?
  type = probe(api_map)
  return self if type.undefined?
  result = proxy(type)
  result.probed = true
  result
end

#reset_generated! ⇒ void

This method returns an undefined value.



161
162
163
164
165
166
167
168
169
170
171
172
173
174
 
# File 'lib/solargraph/pin/base.rb', line 161

def reset_generated!
  # @return_type doesn't go here as subclasses tend to assign it
  # themselves in constructors, and they will deal with setting
  # it in any methods that call this
  #
  # @docstring also doesn't go here, as there is code which
  # directly manipulates docstring without editing comments
  # (e.g., Api::Map::Store#index processes overrides that way
  #
  # Same with @directives, @macros, @maybe_directives, which
  # regenerate docstring
  @deprecated = nil
  reset_conversions
end

#resolve_generics(definitions, context_type) ⇒ self

Determine the concrete type for each of the generic type parameters used in this method based on the parameters passed into the its class and return a new method pin.

Parameters:

  • definitions (Pin::Namespace) —

    The module/class which uses generic types

  • context_type (ComplexType) —

    The receiver type

Returns:

  • (self) 


403
404
405
 
# File 'lib/solargraph/pin/base.rb', line 403

def resolve_generics definitions, context_type
  transform_types { |t| t.resolve_generics(definitions, context_type) if t }
end

#resolve_generics_from_context(generics_to_resolve, return_type_context = nil, resolved_generic_values: {}) ⇒ self

Parameters:

  • generics_to_resolve (Enumerable<String>)
  • return_type_context (ComplexType, nil) (defaults to: nil)
  • context (ComplexType)
  • resolved_generic_values (Hash{String => ComplexType}) (defaults to: {})

Returns:

  • (self) 


383
384
385
386
387
 
# File 'lib/solargraph/pin/base.rb', line 383

def resolve_generics_from_context(generics_to_resolve, return_type_context = nil, resolved_generic_values: {})
  proxy return_type.resolve_generics_from_context(generics_to_resolve,
                                                  return_type_context,
                                                  resolved_generic_values: resolved_generic_values)
end

#symbol_kind ⇒ Integer?

Returns:

  • (Integer, nil) 


430
431
432
 
# File 'lib/solargraph/pin/base.rb', line 430

def symbol_kind
  nil
end

#to_rbs ⇒ String?

Returns:

  • (String, nil) 


599
600
601
 
# File 'lib/solargraph/pin/base.rb', line 599

def to_rbs
  return_type.to_rbs
end

#to_s ⇒ Object 



434
435
436
 
# File 'lib/solargraph/pin/base.rb', line 434

def to_s
  desc
end

#transform_types {|| ... } ⇒ self

Yield Parameters:

Yield Returns:

Returns:

  • (self) 


392
393
394
 
# File 'lib/solargraph/pin/base.rb', line 392

def transform_types(&transform)
  proxy return_type.transform(&transform)
end

#type_desc ⇒ String?

Returns:

  • (String, nil) 


604
605
606
607
608
609
610
611
612
613
614
615
616
617
 
# File 'lib/solargraph/pin/base.rb', line 604

def type_desc
  rbs = to_rbs
  # RBS doesn't have a way to represent a Class<x> type
  rbs = return_type.rooted_tags if return_type.name == 'Class'
  if path
    if rbs
      path + ' ' + rbs
    else
      path
    end
  else
    rbs
  end
end

#typify(api_map) ⇒ ComplexType

Get a fully qualified type from the pin’s return type.

The relative type is determined from YARD documentation (@return, @param, @type, etc.) and its namespaces are fully qualified using the provided ApiMap.

Parameters:

Returns:



524
525
526
 
# File 'lib/solargraph/pin/base.rb', line 524

def typify api_map
  return_type.qualify(api_map, *(closure&.gates || ['']))
end

#variable? ⇒ Boolean

Returns:

  • (Boolean) 


439
440
441
 
# File 'lib/solargraph/pin/base.rb', line 439

def variable?
  false
end