Class: RBS::DefinitionBuilder::MethodBuilder

Inherits:
Object
  • Object
show all
Defined in:
lib/rbs/definition_builder/method_builder.rb

Defined Under Namespace

Classes: Methods

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(env:) ⇒ MethodBuilder

Returns a new instance of MethodBuilder.



83
84
85
86
87
88
89
# File 'lib/rbs/definition_builder/method_builder.rb', line 83

def initialize(env:)
  @env = env

  @instance_methods = {}
  @singleton_methods = {}
  @interface_methods = {}
end

Instance Attribute Details

#envObject (readonly)

Returns the value of attribute env.



78
79
80
# File 'lib/rbs/definition_builder/method_builder.rb', line 78

def env
  @env
end

#instance_methodsObject (readonly)

Returns the value of attribute instance_methods.



79
80
81
# File 'lib/rbs/definition_builder/method_builder.rb', line 79

def instance_methods
  @instance_methods
end

#interface_methodsObject (readonly)

Returns the value of attribute interface_methods.



81
82
83
# File 'lib/rbs/definition_builder/method_builder.rb', line 81

def interface_methods
  @interface_methods
end

#singleton_methodsObject (readonly)

Returns the value of attribute singleton_methods.



80
81
82
# File 'lib/rbs/definition_builder/method_builder.rb', line 80

def singleton_methods
  @singleton_methods
end

Instance Method Details

#build_alias(methods, type, member:, accessibility:) ⇒ Object



169
170
171
172
173
174
# File 'lib/rbs/definition_builder/method_builder.rb', line 169

def build_alias(methods, type, member:, accessibility:)
  defn = methods.methods[member.new_name] ||= Methods::Definition.empty(type: type, name: member.new_name)

  defn.originals << member
  defn.accessibilities << accessibility
end

#build_attribute(methods, type, member:, accessibility:) ⇒ Object



176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
# File 'lib/rbs/definition_builder/method_builder.rb', line 176

def build_attribute(methods, type, member:, accessibility:)
  if member.is_a?(AST::Members::AttrReader) || member.is_a?(AST::Members::AttrAccessor)
    defn = methods.methods[member.name] ||= Methods::Definition.empty(type: type, name: member.name)

    defn.accessibilities << accessibility
    defn.originals << member
  end

  if member.is_a?(AST::Members::AttrWriter) || member.is_a?(AST::Members::AttrAccessor)
    defn = methods.methods[:"#{member.name}="] ||= Methods::Definition.empty(type: type, name: :"#{member.name}=")

    defn.accessibilities << accessibility
    defn.originals << member
  end
end

#build_instance(type_name) ⇒ Object



91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
# File 'lib/rbs/definition_builder/method_builder.rb', line 91

def build_instance(type_name)
  instance_methods[type_name] ||=
    begin
      entry = env.class_decls[type_name]
      args = Types::Variable.build(entry.type_params.each.map(&:name))
      type = Types::ClassInstance.new(name: type_name, args: args, location: nil)
      Methods.new(type: type).tap do |methods|
        entry.decls.each do |d|
          each_member_with_accessibility(d.decl.members) do |member, accessibility|
            case member
            when AST::Members::MethodDefinition
              if member.instance?
                build_method(methods, type, member: member, accessibility: accessibility)
              end
            when AST::Members::AttrReader, AST::Members::AttrWriter, AST::Members::AttrAccessor
              if member.kind == :instance
                build_attribute(methods, type, member: member, accessibility: accessibility)
              end
            when AST::Members::Alias
              if member.kind == :instance
                build_alias(methods, type, member: member, accessibility: accessibility)
              end
            end
          end
        end
      end.validate!
    end
end

#build_interface(type_name) ⇒ Object



149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
# File 'lib/rbs/definition_builder/method_builder.rb', line 149

def build_interface(type_name)
  interface_methods[type_name] ||=
    begin
      entry = env.interface_decls[type_name]
      args = Types::Variable.build(entry.decl.type_params.each.map(&:name))
      type = Types::Interface.new(name: type_name, args: args, location: nil)

      Methods.new(type: type).tap do |methods|
        entry.decl.members.each do |member|
          case member
          when AST::Members::MethodDefinition
            build_method(methods, type, member: member, accessibility: :public)
          when AST::Members::Alias
            build_alias(methods, type, member: member, accessibility: :public)
          end
        end
      end.validate!
    end
end

#build_method(methods, type, member:, accessibility:) ⇒ Object



192
193
194
195
196
197
198
199
200
201
# File 'lib/rbs/definition_builder/method_builder.rb', line 192

def build_method(methods, type, member:, accessibility:)
  defn = methods.methods[member.name] ||= Methods::Definition.empty(type: type, name: member.name)

  if member.overload?
    defn.overloads << member
  else
    defn.accessibilities << accessibility
    defn.originals << member
  end
end

#build_singleton(type_name) ⇒ Object



120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
# File 'lib/rbs/definition_builder/method_builder.rb', line 120

def build_singleton(type_name)
  singleton_methods[type_name] ||=
    begin
      entry = env.class_decls[type_name]
      type = Types::ClassSingleton.new(name: type_name, location: nil)

      Methods.new(type: type).tap do |methods|
        entry.decls.each do |d|
          each_member_with_accessibility(d.decl.members) do |member, accessibility|
            case member
            when AST::Members::MethodDefinition
              if member.singleton?
                build_method(methods, type, member: member, accessibility: accessibility)
              end
            when AST::Members::AttrReader, AST::Members::AttrWriter, AST::Members::AttrAccessor
              if member.kind == :singleton
                build_attribute(methods, type, member: member, accessibility: accessibility)
              end
            when AST::Members::Alias
              if member.kind == :singleton
                build_alias(methods, type, member: member, accessibility: accessibility)
              end
            end
          end
        end
      end.validate!
    end
end

#each_member_with_accessibility(members, accessibility: :public) ⇒ Object



203
204
205
206
207
208
209
210
211
212
213
214
# File 'lib/rbs/definition_builder/method_builder.rb', line 203

def each_member_with_accessibility(members, accessibility: :public)
  members.each do |member|
    case member
    when AST::Members::Public
      accessibility = :public
    when AST::Members::Private
      accessibility = :private
    else
      yield member, accessibility
    end
  end
end