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>) 


479
480
481
482
 
# File 'lib/solargraph/pin/base.rb', line 479

def directives
  parse_comments unless @directives
  @directives
end

#docstring ⇒ YARD::Docstring

Returns:

  • (YARD::Docstring) 


473
474
475
476
 
# File 'lib/solargraph/pin/base.rb', line 473

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:



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

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 (self) 


460
461
462
463
 
# File 'lib/solargraph/pin/base.rb', line 460

def == other
  return false unless nearly? other
  comments == other.comments && location == other.location
end

#all_location_text ⇒ String

Returns:

  • (String) 


616
617
618
619
620
621
622
623
624
625
626
 
# File 'lib/solargraph/pin/base.rb', line 616

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) 


399
400
401
 
# File 'lib/solargraph/pin/base.rb', line 399

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) 


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

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) 


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

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) 


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

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
 
# 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)
  assert_same_array_content(other, :macros) { |macro| macro.tag.name }
end

#assert_source_provided ⇒ void

This method returns an undefined value.



361
362
363
 
# File 'lib/solargraph/pin/base.rb', line 361

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

#best_location ⇒ Location?

Returns:



436
437
438
 
# File 'lib/solargraph/pin/base.rb', line 436

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

Parameters:

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

Returns:

  • (undefined) 


343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
 
# File 'lib/solargraph/pin/base.rb', line 343

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
  # @sg-ignore Need _1 support
  [val1, val2].compact.min_by { _1.best_location.to_s }
end

#choose_pin_attr_with_same_name(other, attr) ⇒ undefined

@sg-ignore

Parameters:

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

Returns:

  • (undefined) 


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

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.rooted_tag }
      # assume this was a declaration that should have said 'self'
      all_items.delete_if { |item| item.rooted_tag == context.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) 


366
367
368
 
# File 'lib/solargraph/pin/base.rb', line 366

def comments
  @comments ||= ''
end

#completion_item_kind ⇒ Integer

Returns:

  • (Integer) 


417
418
419
 
# File 'lib/solargraph/pin/base.rb', line 417

def completion_item_kind
  LanguageServer::CompletionItemKinds::KEYWORD
end

#deprecated? ⇒ Boolean

Returns:

  • (Boolean) 


503
504
505
 
# File 'lib/solargraph/pin/base.rb', line 503

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

#desc ⇒ String

Returns:

  • (String) 


606
607
608
 
# File 'lib/solargraph/pin/base.rb', line 606

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) 


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

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) 


411
412
413
414
 
# File 'lib/solargraph/pin/base.rb', line 411

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

#identity ⇒ String

Deprecated.

Returns:

  • (String) 


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

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

#infer(api_map) ⇒ ComplexType

Deprecated.

Use #typify and/or #probe instead

Parameters:

Returns:



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

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) 


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

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) 


611
612
613
 
# File 'lib/solargraph/pin/base.rb', line 611

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

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

Returns:

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


485
486
487
 
# File 'lib/solargraph/pin/base.rb', line 485

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) 


497
498
499
500
 
# File 'lib/solargraph/pin/base.rb', line 497

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) 


446
447
448
449
450
451
452
453
454
 
# File 'lib/solargraph/pin/base.rb', line 446

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:



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

def probe api_map
  typify api_map
end

#probed? ⇒ Boolean

Returns:

  • (Boolean) 


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

def probed?
  @probed ||= false
end

#proxied? ⇒ Boolean

Returns:

  • (Boolean) 


537
538
539
 
# File 'lib/solargraph/pin/base.rb', line 537

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) 


564
565
566
567
568
569
 
# File 'lib/solargraph/pin/base.rb', line 564

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) 


547
548
549
550
551
552
553
554
555
556
 
# File 'lib/solargraph/pin/base.rb', line 547

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) 


395
396
397
 
# File 'lib/solargraph/pin/base.rb', line 395

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) 


375
376
377
378
379
 
# File 'lib/solargraph/pin/base.rb', line 375

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) 


422
423
424
 
# File 'lib/solargraph/pin/base.rb', line 422

def symbol_kind
  nil
end

#to_rbs ⇒ String?

Returns:

  • (String, nil) 


578
579
580
 
# File 'lib/solargraph/pin/base.rb', line 578

def to_rbs
  return_type.to_rbs
end

#to_s ⇒ Object 



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

def to_s
  desc
end

#transform_types {|| ... } ⇒ self

Yield Parameters:

Yield Returns:

Returns:

  • (self) 


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

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

#type_desc ⇒ String

Returns:

  • (String) 


583
584
585
586
587
588
589
590
591
592
593
594
595
596
 
# File 'lib/solargraph/pin/base.rb', line 583

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:



515
516
517
 
# File 'lib/solargraph/pin/base.rb', line 515

def typify api_map
  return_type.qualify(api_map, namespace)
end

#variable? ⇒ Boolean

Returns:

  • (Boolean) 


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

def variable?
  false
end