Class: RBS::Inline::AST::Members::RubyDef

Inherits:
RubyBase show all
Defined in:
lib/rbs/inline/ast/members.rb

Instance Attribute Summary collapse

Attributes inherited from Base

#location

Instance Method Summary collapse

Methods inherited from Base

#start_line

Constructor Details

#initialize(node, comments, visibility, assertion) ⇒ RubyDef

Returns a new instance of RubyDef.



52
53
54
55
56
57
58
59
 
# File 'lib/rbs/inline/ast/members.rb', line 52

def initialize(node, comments, visibility, assertion) #: void
  @node = node
  @comments = comments
  @visibility = visibility
  @assertion = assertion

  super(node.location)
end

Instance Attribute Details

#assertion ⇒ Object (readonly)

Assertion given at the end of the method name



46
47
48
 
# File 'lib/rbs/inline/ast/members.rb', line 46

def assertion
  @assertion
end

#comments ⇒ Object (readonly)

: AnnotationParser::ParsingResult?



32
33
34
 
# File 'lib/rbs/inline/ast/members.rb', line 32

def comments
  @comments
end

#node ⇒ Object (readonly)

: Prism::DefNode



31
32
33
 
# File 'lib/rbs/inline/ast/members.rb', line 31

def node
  @node
end

#visibility ⇒ Object (readonly)

The visibility directly attached to the def node

nil when the def node is not passed to private/public calls.

“‘rb def foo() end # <= nil private def foo() end # <= :private “`



42
43
44
 
# File 'lib/rbs/inline/ast/members.rb', line 42

def visibility
  @visibility
end

Instance Method Details

#annotated_method_types ⇒ Object

Returns nil if no ‘@rbs METHOD-TYPE` or #: annotation is given

Returns an empty array if only ... method type is given.



70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
 
# File 'lib/rbs/inline/ast/members.rb', line 70

def annotated_method_types #: Array[MethodType]?
  if comments
    method_type_annotations = comments.each_annotation.select do |annotation|
      annotation.is_a?(Annotations::MethodTypeAssertion) || annotation.is_a?(Annotations::Method) || annotation.is_a?(Annotations::Dot3Assertion)
    end

    return nil if method_type_annotations.empty?

    method_type_annotations.each_with_object([]) do |annotation, method_types| #$ Array[MethodType]
      case annotation
      when Annotations::MethodTypeAssertion
        method_types << annotation.method_type
      when Annotations::Method
        annotation.each_method_type do
          method_types << _1
        end
      end
    end
  end
end

#block_type_annotation ⇒ Object

: AST::Annotations::BlockType?



299
300
301
302
303
304
305
 
# File 'lib/rbs/inline/ast/members.rb', line 299

def block_type_annotation #: AST::Annotations::BlockType?
  if comments
    comments.each_annotation.find do |annotation|
      annotation.is_a?(AST::Annotations::BlockType)
    end #: AST::Annotations::BlockType?
  end
end

#double_splat_param_type_annotation ⇒ Object

: Annotations::DoubleSplatParamType?



131
132
133
134
135
136
137
 
# File 'lib/rbs/inline/ast/members.rb', line 131

def double_splat_param_type_annotation #: Annotations::DoubleSplatParamType?
  if comments
    comments.each_annotation.find do |annotation|
      annotation.is_a?(Annotations::DoubleSplatParamType)
    end #: Annotations::DoubleSplatParamType?
  end
end

#method_annotations ⇒ Object

: Array



276
277
278
279
280
281
282
283
284
285
286
287
288
 
# File 'lib/rbs/inline/ast/members.rb', line 276

def method_annotations #: Array[RBS::AST::Annotation]
  if comments
    comments.each_annotation.flat_map do |annotation|
      if annotation.is_a?(AST::Annotations::RBSAnnotation)
        annotation.annotations
      else
        []
      end
    end
  else
    []
  end
end

#method_name ⇒ Object

Returns the name of the method



62
63
64
 
# File 'lib/rbs/inline/ast/members.rb', line 62

def method_name #: Symbol
  node.name
end

#method_overloads ⇒ Object

: Array



155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
 
# File 'lib/rbs/inline/ast/members.rb', line 155

def method_overloads #: Array[RBS::AST::Members::MethodDefinition::Overload]
  case
  when method_types = annotated_method_types
    method_types.map do |method_type|
      RBS::AST::Members::MethodDefinition::Overload.new(
        method_type: method_type,
        annotations: []
      )
    end
  else
    required_positionals = [] #: Array[Types::Function::Param]
    optional_positionals = [] #: Array[Types::Function::Param]
    rest_positionals = nil #: Types::Function::Param?
    required_keywords = {} #: Hash[Symbol, Types::Function::Param]
    optional_keywords = {} #: Hash[Symbol, Types::Function::Param]
    rest_keywords = nil #: Types::Function::Param?

    if node.parameters
      node.parameters.requireds.each do |param|
        case param
        when Prism::RequiredParameterNode
          required_positionals << Types::Function::Param.new(
            name: param.name,
            type: var_type_hash[param.name] || Types::Bases::Any.new(location: nil),
            location: nil
          )
        end
      end

      node.parameters.optionals.each do |param|
        case param
        when Prism::OptionalParameterNode
          optional_positionals << Types::Function::Param.new(
            name: param.name,
            type: var_type_hash[param.name] || Types::Bases::Any.new(location: nil),
            location: nil
          )
        end
      end

      if (rest = node.parameters.rest).is_a?(Prism::RestParameterNode)
        splat_param_type = splat_param_type_annotation

        if splat_param_type && splat_param_type.type
          splat_type = splat_param_type.type
        end

        rest_positionals = Types::Function::Param.new(
          name: rest.name,
          type: splat_type || Types::Bases::Any.new(location: nil),
          location: nil
        )
      end

      node.parameters.keywords.each do |node|
        if node.is_a?(Prism::RequiredKeywordParameterNode)
          required_keywords[node.name] = Types::Function::Param.new(
            name: nil,
            type: var_type_hash[node.name] || Types::Bases::Any.new(location: nil),
            location: nil
          )
        end

        if node.is_a?(Prism::OptionalKeywordParameterNode)
          optional_keywords[node.name] = Types::Function::Param.new(
            name: nil,
            type: var_type_hash[node.name] || Types::Bases::Any.new(location: nil),
            location: nil
          )
        end
      end

      if (kw_rest = node.parameters.keyword_rest).is_a?(Prism::KeywordRestParameterNode)
        double_splat_param_type = double_splat_param_type_annotation

        if double_splat_param_type && double_splat_param_type.type
          double_splat_type = double_splat_param_type.type
        end

        rest_keywords = Types::Function::Param.new(
          name: kw_rest.name,
          type: double_splat_type || Types::Bases::Any.new(location: nil),
          location: nil)
      end

      if node.parameters.block
        block = Types::Block.new(
          type: Types::UntypedFunction.new(return_type: Types::Bases::Any.new(location: nil)),
          required: false,
          self_type: nil
        )
      end
    end

    if type = block_type_annotation&.type
      block = type
    end

    [
      RBS::AST::Members::MethodDefinition::Overload.new(
        method_type: RBS::MethodType.new(
          type_params: [],
          type: Types::Function.new(
            required_positionals: required_positionals,
            optional_positionals: optional_positionals,
            rest_positionals: rest_positionals,
            trailing_positionals: [],
            required_keywords: required_keywords,
            optional_keywords: optional_keywords,
            rest_keywords: rest_keywords,
            return_type: return_type || Types::Bases::Any.new(location: nil)
          ),
          block: block,
          location: nil
        ),
        annotations: []
      )
    ]
  end
end

#overloading? ⇒ Boolean

: bool

Returns:

  • (Boolean) 


139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
 
# File 'lib/rbs/inline/ast/members.rb', line 139

def overloading? #: bool
  if comments
    comments.each_annotation do |annotation|
      if annotation.is_a?(Annotations::Method)
        return true if annotation.overloading
      end
      if annotation.is_a?(Annotations::Dot3Assertion)
        return true
      end
    end
    false
  else
    false
  end
end

#override_annotation ⇒ Object

Returns the ‘@rbs override` annotation



291
292
293
294
295
296
297
 
# File 'lib/rbs/inline/ast/members.rb', line 291

def override_annotation #: AST::Annotations::Override?
  if comments
    comments.each_annotation.find do |annotation|
      annotation.is_a?(AST::Annotations::Override)
    end #: AST::Annotations::Override?
  end
end

#return_type ⇒ Object

: Types::t?



91
92
93
94
95
96
97
98
99
100
101
102
 
# File 'lib/rbs/inline/ast/members.rb', line 91

def return_type #: Types::t?
  if assertion
    return assertion.type
  end

  if comments
    annot = comments.each_annotation.find {|annot| annot.is_a?(Annotations::ReturnType ) } #: Annotations::ReturnType?
    if annot
      annot.type
    end
  end
end

#splat_param_type_annotation ⇒ Object

: Annotations::SplatParamType?



123
124
125
126
127
128
129
 
# File 'lib/rbs/inline/ast/members.rb', line 123

def splat_param_type_annotation #: Annotations::SplatParamType?
  if comments
    comments.each_annotation.find do |annotation|
      annotation.is_a?(Annotations::SplatParamType)
    end #: Annotations::SplatParamType?
  end
end

#var_type_hash ⇒ Object

: Hash[Symbol, Types::t?]



104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
 
# File 'lib/rbs/inline/ast/members.rb', line 104

def var_type_hash #: Hash[Symbol, Types::t?]
  types = {} #: Hash[Symbol, Types::t?]

  if comments
    comments.each_annotation.each do |annotation|
      if annotation.is_a?(Annotations::VarType)
        name = annotation.name
        type = annotation.type

        if name
          types[name] = type
        end
      end
    end
  end

  types
end