rbs 0.20.1 → 1.0.0.pre

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -2,728 +2,408 @@ module RBS
2
2
  class DefinitionBuilder
3
3
  attr_reader :env
4
4
  attr_reader :type_name_resolver
5
+ attr_reader :ancestor_builder
6
+ attr_reader :method_builder
5
7
 
6
8
  attr_reader :instance_cache
7
9
  attr_reader :singleton_cache
10
+ attr_reader :singleton0_cache
8
11
  attr_reader :interface_cache
9
12
 
10
- attr_reader :one_instance_cache
11
- attr_reader :one_singleton_cache
12
-
13
- attr_reader :instance_ancestors_cache
14
- attr_reader :singleton_ancestor_cache
15
-
16
- attr_reader :one_instance_ancestors_cache
17
- attr_reader :one_singleton_ancestors_cache
18
-
19
- class OneAncestors
20
- attr_reader :type_name
21
- attr_reader :params
22
- attr_reader :super_class
23
- attr_reader :self_types
24
- attr_reader :included_modules
25
- attr_reader :prepended_modules
26
- attr_reader :extended_modules
27
-
28
- def initialize(type_name:, params:, super_class:, self_types:, included_modules:, prepended_modules:, extended_modules:)
29
- @type_name = type_name
30
- @params = params
31
- @super_class = super_class
32
- @self_types = self_types
33
- @included_modules = included_modules
34
- @prepended_modules = prepended_modules
35
- @extended_modules = extended_modules
36
- end
37
-
38
- def each_ancestor(&block)
39
- if block
40
- if s = super_class
41
- yield s
42
- end
43
-
44
- self_types&.each(&block)
45
- included_modules&.each(&block)
46
- prepended_modules&.each(&block)
47
- extended_modules&.each(&block)
48
- else
49
- enum_for :each_ancestor
50
- end
51
- end
52
-
53
- def self.class_instance(type_name:, params:, super_class:)
54
- new(
55
- type_name: type_name,
56
- params: params,
57
- super_class: super_class,
58
- self_types: nil,
59
- included_modules: [],
60
- prepended_modules: [],
61
- extended_modules: nil
62
- )
63
- end
64
-
65
- def self.singleton(type_name:, super_class:)
66
- new(
67
- type_name: type_name,
68
- params: nil,
69
- super_class: super_class,
70
- self_types: nil,
71
- included_modules: nil,
72
- prepended_modules: nil,
73
- extended_modules: []
74
- )
75
- end
76
-
77
- def self.module_instance(type_name:, params:)
78
- new(
79
- type_name: type_name,
80
- params: params,
81
- self_types: [],
82
- included_modules: [],
83
- prepended_modules: [],
84
- super_class: nil,
85
- extended_modules: nil
86
- )
87
- end
88
- end
89
-
90
13
  def initialize(env:)
91
14
  @env = env
92
15
  @type_name_resolver = TypeNameResolver.from_env(env)
16
+ @ancestor_builder = AncestorBuilder.new(env: env)
17
+ @method_builder = MethodBuilder.new(env: env)
93
18
 
94
19
  @instance_cache = {}
95
20
  @singleton_cache = {}
21
+ @singleton0_cache = {}
96
22
  @interface_cache = {}
97
-
98
- @one_instance_cache = {}
99
- @one_singleton_cache = {}
100
-
101
- @instance_ancestors_cache = {}
102
- @singleton_ancestor_cache = {}
103
-
104
- @one_instance_ancestors_cache = {}
105
- @one_singleton_ancestors_cache = {}
106
- end
107
-
108
- def validate_super_class!(type_name, entry)
109
- with_super_classes = entry.decls.select {|d| d.decl.super_class }
110
-
111
- return if with_super_classes.size <= 1
112
-
113
- super_types = with_super_classes.map do |d|
114
- super_class = d.decl.super_class or raise
115
- Types::ClassInstance.new(name: super_class.name, args: super_class.args, location: nil)
116
- end
117
-
118
- super_types.uniq!
119
-
120
- return if super_types.size == 1
121
-
122
- raise SuperclassMismatchError.new(name: type_name, super_classes: super_types, entry: entry)
123
23
  end
124
24
 
125
- def one_instance_ancestors(type_name)
126
- as = one_instance_ancestors_cache[type_name] and return as
127
-
128
- entry = env.class_decls[type_name] or raise "Unknown name for one_instance_ancestors: #{type_name}"
129
- params = entry.type_params.each.map(&:name)
130
-
131
- case entry
132
- when Environment::ClassEntry
133
- validate_super_class!(type_name, entry)
134
- primary = entry.primary
135
- super_class = primary.decl.super_class
136
-
137
- if type_name != BuiltinNames::BasicObject.name
138
- if super_class
139
- super_name = super_class.name
140
- super_args = super_class.args
141
- else
142
- super_name = BuiltinNames::Object.name
143
- super_args = []
144
- end
145
-
146
- NoSuperclassFoundError.check!(super_name, env: env, location: primary.decl.location)
147
-
148
- ancestors = OneAncestors.class_instance(
149
- type_name: type_name,
150
- params: params,
151
- super_class: Definition::Ancestor::Instance.new(name: super_name, args: super_args)
152
- )
153
- else
154
- ancestors = OneAncestors.class_instance(
155
- type_name: type_name,
156
- params: params,
157
- super_class: nil
158
- )
159
- end
160
- when Environment::ModuleEntry
161
- ancestors = OneAncestors.module_instance(type_name: type_name, params: params)
162
-
163
- entry.self_types.each do |module_self|
164
- NoSelfTypeFoundError.check!(module_self, env: env)
165
-
166
- self_types = ancestors.self_types or raise
167
- self_types.push Definition::Ancestor::Instance.new(name: module_self.name, args: module_self.args)
168
- end
169
- end
170
-
171
- mixin_ancestors(entry,
172
- included_modules: ancestors.included_modules,
173
- prepended_modules: ancestors.prepended_modules,
174
- extended_modules: nil)
175
-
176
- one_instance_ancestors_cache[type_name] = ancestors
177
- end
178
-
179
- def one_singleton_ancestors(type_name)
180
- as = one_singleton_ancestors_cache[type_name] and return as
181
-
182
- entry = env.class_decls[type_name] or raise "Unknown name for one_singleton_ancestors: #{type_name}"
183
-
184
- case entry
185
- when Environment::ClassEntry
186
- validate_super_class!(type_name, entry)
187
- primary = entry.primary
188
- super_class = primary.decl.super_class
189
-
190
- if type_name != BuiltinNames::BasicObject.name
191
- if super_class
192
- super_name = super_class.name
193
- else
194
- super_name = BuiltinNames::Object.name
195
- end
196
-
197
- NoSuperclassFoundError.check!(super_name, env: env, location: primary.decl.location)
198
-
199
- ancestors = OneAncestors.singleton(
200
- type_name: type_name,
201
- super_class: Definition::Ancestor::Singleton.new(name: super_name)
202
- )
203
- else
204
- ancestors = OneAncestors.singleton(
205
- type_name: type_name,
206
- super_class: Definition::Ancestor::Instance.new(name: BuiltinNames::Class.name, args: [])
207
- )
25
+ def ensure_namespace!(namespace, location:)
26
+ namespace.ascend do |ns|
27
+ unless ns.empty?
28
+ NoTypeFoundError.check!(ns.to_type_name, env: env, location: location)
208
29
  end
209
- when Environment::ModuleEntry
210
- ancestors = OneAncestors.singleton(
211
- type_name: type_name,
212
- super_class: Definition::Ancestor::Instance.new(name: BuiltinNames::Module.name, args: [])
213
- )
214
30
  end
215
-
216
- mixin_ancestors(entry,
217
- included_modules: nil,
218
- prepended_modules: nil,
219
- extended_modules: ancestors.extended_modules)
220
-
221
- one_singleton_ancestors_cache[type_name] = ancestors
222
31
  end
223
32
 
224
- def mixin_ancestors(entry, included_modules:, extended_modules:, prepended_modules:)
225
- entry.decls.each do |d|
226
- decl = d.decl
33
+ def build_interface(type_name)
34
+ try_cache(type_name, cache: interface_cache) do
35
+ entry = env.interface_decls[type_name] or raise "Unknown name for build_interface: #{type_name}"
36
+ declaration = entry.decl
37
+ ensure_namespace!(type_name.namespace, location: declaration.location)
227
38
 
228
- align_params = Substitution.build(
229
- decl.type_params.each.map(&:name),
230
- Types::Variable.build(entry.type_params.each.map(&:name))
39
+ self_type = Types::Interface.new(
40
+ name: type_name,
41
+ args: Types::Variable.build(declaration.type_params.each.map(&:name)),
42
+ location: nil
231
43
  )
232
44
 
233
- decl.each_mixin do |member|
234
- case member
235
- when AST::Members::Include
236
- if included_modules
237
- NoMixinFoundError.check!(member.name, env: env, member: member)
238
-
239
- module_name = member.name
240
- module_args = member.args.map {|type| type.sub(align_params) }
241
-
242
- included_modules << Definition::Ancestor::Instance.new(name: module_name, args: module_args)
243
- end
244
-
245
- when AST::Members::Prepend
246
- if prepended_modules
247
- NoMixinFoundError.check!(member.name, env: env, member: member)
248
-
249
- module_name = member.name
250
- module_args = member.args.map {|type| type.sub(align_params) }
251
-
252
- prepended_modules << Definition::Ancestor::Instance.new(name: module_name, args: module_args)
253
- end
254
-
255
- when AST::Members::Extend
256
- if extended_modules
257
- NoMixinFoundError.check!(member.name, env: env, member: member)
258
-
259
- module_name = member.name
260
- module_args = member.args
45
+ ancestors = ancestor_builder.interface_ancestors(type_name)
46
+ Definition.new(type_name: type_name, entry: entry, self_type: self_type, ancestors: ancestors).tap do |definition|
47
+ ancestor_builder.one_interface_ancestors(type_name).included_interfaces.each do |mod|
48
+ defn = build_interface(mod.name)
49
+ subst = Substitution.build(defn.type_params, mod.args)
261
50
 
262
- extended_modules << Definition::Ancestor::Instance.new(name: module_name, args: module_args)
51
+ defn.methods.each do |name, method|
52
+ definition.methods[name] = method.sub(subst)
263
53
  end
264
54
  end
265
- end
266
- end
267
- end
268
-
269
- def instance_ancestors(type_name, building_ancestors: [])
270
- as = instance_ancestors_cache[type_name] and return as
271
-
272
- entry = env.class_decls[type_name] or raise "Unknown name for instance_ancestors: #{type_name}"
273
- params = entry.type_params.each.map(&:name)
274
- args = Types::Variable.build(params)
275
- self_ancestor = Definition::Ancestor::Instance.new(name: type_name, args: args)
276
-
277
- RecursiveAncestorError.check!(self_ancestor,
278
- ancestors: building_ancestors,
279
- location: entry.primary.decl.location)
280
- building_ancestors.push self_ancestor
281
-
282
- one_ancestors = one_instance_ancestors(type_name)
283
-
284
- ancestors = []
285
55
 
286
- case entry
287
- when Environment::ClassEntry
288
- if super_class = one_ancestors.super_class
289
- # @type var super_class: Definition::Ancestor::Instance
290
- super_name = super_class.name
291
- super_args = super_class.args
292
-
293
- super_ancestors = instance_ancestors(super_name, building_ancestors: building_ancestors)
294
- ancestors.unshift(*super_ancestors.apply(super_args, location: entry.primary.decl.location))
295
- end
296
- end
297
-
298
- if included_modules = one_ancestors.included_modules
299
- included_modules.each do |mod|
300
- if mod.name.class?
301
- name = mod.name
302
- arg_types = mod.args
303
- mod_ancestors = instance_ancestors(name, building_ancestors: building_ancestors)
304
- ancestors.unshift(*mod_ancestors.apply(arg_types, location: entry.primary.decl.location))
305
- end
306
- end
307
- end
56
+ methods = method_builder.build_interface(type_name)
57
+ methods.each do |defn|
58
+ method = case defn.original
59
+ when AST::Members::MethodDefinition
60
+ defs = defn.original.types.map do |method_type|
61
+ Definition::Method::TypeDef.new(
62
+ type: method_type,
63
+ member: defn.original,
64
+ defined_in: type_name,
65
+ implemented_in: nil
66
+ )
67
+ end
68
+
69
+ Definition::Method.new(
70
+ super_method: nil,
71
+ defs: defs,
72
+ accessibility: :public,
73
+ alias_of: nil
74
+ )
75
+ when AST::Members::Alias
76
+ unless definition.methods.key?(defn.original.old_name)
77
+ raise UnknownMethodAliasError.new(
78
+ original_name: defn.original.old_name,
79
+ aliased_name: defn.original.new_name,
80
+ location: defn.original.location
81
+ )
82
+ end
83
+
84
+ original_method = definition.methods[defn.original.old_name]
85
+ Definition::Method.new(
86
+ super_method: nil,
87
+ defs: original_method.defs.map do |defn|
88
+ defn.update(implemented_in: nil, defined_in: type_name)
89
+ end,
90
+ accessibility: :public,
91
+ alias_of: original_method
92
+ )
93
+ when nil
94
+ unless definition.methods.key?(defn.name)
95
+ raise InvalidOverloadMethodError.new(
96
+ type_name: type_name,
97
+ method_name: defn.name,
98
+ kind: :instance,
99
+ members: defn.overloads
100
+ )
101
+ end
102
+
103
+ definition.methods[defn.name]
104
+ end
105
+
106
+ defn.overloads.each do |overload|
107
+ defs = overload.types.map do |method_type|
108
+ Definition::Method::TypeDef.new(
109
+ type: method_type,
110
+ member: overload,
111
+ defined_in: type_name,
112
+ implemented_in: nil
113
+ )
114
+ end
308
115
 
309
- ancestors.unshift(self_ancestor)
116
+ method.defs.unshift(*defs)
117
+ end
310
118
 
311
- if prepended_modules = one_ancestors.prepended_modules
312
- prepended_modules.each do |mod|
313
- if mod.name.class?
314
- name = mod.name
315
- arg_types = mod.args
316
- mod_ancestors = instance_ancestors(name, building_ancestors: building_ancestors)
317
- ancestors.unshift(*mod_ancestors.apply(arg_types, location: entry.primary.decl.location))
119
+ definition.methods[defn.name] = method
318
120
  end
319
121
  end
320
122
  end
321
-
322
- building_ancestors.pop
323
-
324
- instance_ancestors_cache[type_name] = Definition::InstanceAncestors.new(
325
- type_name: type_name,
326
- params: params,
327
- ancestors: ancestors
328
- )
329
123
  end
330
124
 
331
- def singleton_ancestors(type_name, building_ancestors: [])
332
- as = singleton_ancestor_cache[type_name] and return as
333
-
334
- entry = env.class_decls[type_name] or raise "Unknown name for singleton_ancestors: #{type_name}"
335
- self_ancestor = Definition::Ancestor::Singleton.new(name: type_name)
336
-
337
- RecursiveAncestorError.check!(self_ancestor,
338
- ancestors: building_ancestors,
339
- location: entry.primary.decl.location)
340
- building_ancestors.push self_ancestor
341
-
342
- one_ancestors = one_singleton_ancestors(type_name)
125
+ def build_instance(type_name)
126
+ try_cache(type_name, cache: instance_cache) do
127
+ entry = env.class_decls[type_name] or raise "Unknown name for build_instance: #{type_name}"
128
+ ensure_namespace!(type_name.namespace, location: entry.decls[0].decl.location)
343
129
 
344
- ancestors = []
130
+ case entry
131
+ when Environment::ClassEntry, Environment::ModuleEntry
132
+ ancestors = ancestor_builder.instance_ancestors(type_name)
133
+ self_type = Types::ClassInstance.new(name: type_name,
134
+ args: Types::Variable.build(entry.type_params.each.map(&:name)),
135
+ location: nil)
345
136
 
346
- case super_class = one_ancestors.super_class
347
- when Definition::Ancestor::Instance
348
- super_name = super_class.name
349
- super_args = super_class.args
137
+ Definition.new(type_name: type_name, entry: entry, self_type: self_type, ancestors: ancestors).tap do |definition|
138
+ one_ancestors = ancestor_builder.one_instance_ancestors(type_name)
139
+ methods = method_builder.build_instance(type_name)
350
140
 
351
- super_ancestors = instance_ancestors(super_name, building_ancestors: building_ancestors)
352
- ancestors.unshift(*super_ancestors.apply(super_args, location: entry.primary.decl.location))
141
+ validate_type_params definition, methods: methods, ancestors: one_ancestors
353
142
 
354
- when Definition::Ancestor::Singleton
355
- super_name = super_class.name
143
+ if super_class = one_ancestors.super_class
144
+ defn = build_instance(super_class.name)
145
+ merge_definition(src: defn,
146
+ dest: definition,
147
+ subst: Substitution.build(defn.type_params, super_class.args),
148
+ keep_super: true)
149
+ end
356
150
 
357
- super_ancestors = singleton_ancestors(super_name, building_ancestors: [])
358
- ancestors.unshift(*super_ancestors.ancestors)
359
- end
151
+ if one_ancestors.self_types
152
+ one_ancestors.self_types.each do |ans|
153
+ defn = if ans.name.interface?
154
+ build_interface(ans.name)
155
+ else
156
+ build_instance(ans.name)
157
+ end
158
+
159
+ # Successor interface method overwrites.
160
+ merge_definition(src: defn,
161
+ dest: definition,
162
+ subst: Substitution.build(defn.type_params, ans.args),
163
+ keep_super: true)
164
+ end
165
+ end
360
166
 
361
- extended_modules = one_ancestors.extended_modules or raise
362
- extended_modules.each do |mod|
363
- if mod.name.class?
364
- name = mod.name
365
- args = mod.args
366
- mod_ancestors = instance_ancestors(name, building_ancestors: building_ancestors)
367
- ancestors.unshift(*mod_ancestors.apply(args, location: entry.primary.decl.location))
368
- end
369
- end
167
+ one_ancestors.included_modules.each do |mod|
168
+ defn = build_instance(mod.name)
169
+ merge_definition(src: defn,
170
+ dest: definition,
171
+ subst: Substitution.build(defn.type_params, mod.args))
172
+ end
370
173
 
371
- ancestors.unshift(self_ancestor)
174
+ interface_methods = {}
372
175
 
373
- building_ancestors.pop
176
+ one_ancestors.included_interfaces.each do |mod|
177
+ defn = build_interface(mod.name)
178
+ subst = Substitution.build(defn.type_params, mod.args)
374
179
 
375
- singleton_ancestor_cache[type_name] = Definition::SingletonAncestors.new(
376
- type_name: type_name,
377
- ancestors: ancestors
378
- )
379
- end
380
-
381
- def each_member_with_accessibility(members, accessibility: :public)
382
- members.each do |member|
383
- case member
384
- when AST::Members::Public
385
- accessibility = :public
386
- when AST::Members::Private
387
- accessibility = :private
388
- else
389
- yield member, accessibility
390
- end
391
- end
392
- end
180
+ defn.methods.each do |name, method|
181
+ if interface_methods.key?(name)
182
+ raise DuplicatedInterfaceMethodDefinitionError.new(
183
+ type: self_type,
184
+ method_name: name,
185
+ member: mod.source
186
+ )
187
+ end
393
188
 
394
- def ensure_namespace!(namespace, location:)
395
- namespace.ascend do |ns|
396
- unless ns.empty?
397
- NoTypeFoundError.check!(ns.to_type_name, env: env, location: location)
398
- end
399
- end
400
- end
189
+ merge_method(type_name, interface_methods, name, method, subst, implemented_in: type_name)
190
+ end
191
+ end
401
192
 
402
- def build_instance(type_name)
403
- try_cache type_name, cache: instance_cache do
404
- entry = env.class_decls[type_name] or raise "Unknown name for build_instance: #{type_name}"
405
- ensure_namespace!(type_name.namespace, location: entry.decls[0].decl.location)
193
+ define_methods(definition,
194
+ interface_methods: interface_methods,
195
+ methods: methods,
196
+ super_interface_method: entry.is_a?(Environment::ModuleEntry))
197
+
198
+ entry.decls.each do |d|
199
+ d.decl.members.each do |member|
200
+ case member
201
+ when AST::Members::AttrReader, AST::Members::AttrAccessor, AST::Members::AttrWriter
202
+ if member.kind == :instance
203
+ ivar_name = case member.ivar_name
204
+ when false
205
+ nil
206
+ else
207
+ member.ivar_name || :"@#{member.name}"
208
+ end
209
+
210
+ if ivar_name
211
+ insert_variable(type_name, definition.instance_variables, name: ivar_name, type: member.type)
212
+ end
213
+ end
406
214
 
407
- case entry
408
- when Environment::ClassEntry, Environment::ModuleEntry
409
- ancestors = instance_ancestors(type_name)
410
- self_type = Types::ClassInstance.new(name: type_name,
411
- args: Types::Variable.build(entry.type_params.each.map(&:name)),
412
- location: nil)
215
+ when AST::Members::InstanceVariable
216
+ insert_variable(type_name, definition.instance_variables, name: member.name, type: member.type)
413
217
 
414
- definition_pairs = ancestors.ancestors.map do |ancestor|
415
- # @type block: [Definition::Ancestor::t, Definition]
416
- case ancestor
417
- when Definition::Ancestor::Instance
418
- [ancestor, build_one_instance(ancestor.name)]
419
- when Definition::Ancestor::Singleton
420
- [ancestor, build_one_singleton(ancestor.name)]
218
+ when AST::Members::ClassVariable
219
+ insert_variable(type_name, definition.class_variables, name: member.name, type: member.type)
220
+ end
221
+ end
421
222
  end
422
- end
423
223
 
424
- case entry
425
- when Environment::ModuleEntry
426
- entry.self_types.each do |module_self|
427
- ancestor = Definition::Ancestor::Instance.new(name: module_self.name, args: module_self.args)
428
- definition_pairs.push(
429
- [
430
- ancestor,
431
- if module_self.name.interface?
432
- build_interface(module_self.name)
433
- else
434
- build_instance(module_self.name)
435
- end
436
- ]
437
- )
224
+ one_ancestors.prepended_modules.each do |mod|
225
+ defn = build_instance(mod.name)
226
+ merge_definition(src: defn,
227
+ dest: definition,
228
+ subst: Substitution.build(defn.type_params, mod.args))
438
229
  end
439
230
  end
440
-
441
- merge_definitions(type_name, definition_pairs, entry: entry, self_type: self_type, ancestors: ancestors)
442
231
  end
443
232
  end
444
233
  end
445
234
 
446
- def build_singleton(type_name)
447
- try_cache type_name, cache: singleton_cache do
448
- entry = env.class_decls[type_name] or raise "Unknown name for build_singleton: #{type_name}"
235
+ # Builds a definition for singleton without .new method.
236
+ #
237
+ def build_singleton0(type_name)
238
+ try_cache type_name, cache: singleton0_cache do
239
+ entry = env.class_decls[type_name] or raise "Unknown name for build_singleton0: #{type_name}"
449
240
  ensure_namespace!(type_name.namespace, location: entry.decls[0].decl.location)
450
241
 
451
242
  case entry
452
243
  when Environment::ClassEntry, Environment::ModuleEntry
453
- ancestors = singleton_ancestors(type_name)
244
+ ancestors = ancestor_builder.singleton_ancestors(type_name)
454
245
  self_type = Types::ClassSingleton.new(name: type_name, location: nil)
455
- instance_type = Types::ClassInstance.new(
456
- name: type_name,
457
- args: Types::Variable.build(entry.type_params.each.map(&:name)),
458
- location: nil
459
- )
460
246
 
461
- definition_pairs = ancestors.ancestors.map do |ancestor|
462
- # @type block: [Definition::Ancestor::t, Definition]
463
- case ancestor
464
- when Definition::Ancestor::Instance
465
- [ancestor, build_one_instance(ancestor.name)]
466
- when Definition::Ancestor::Singleton
467
- definition = build_one_singleton(ancestor.name)
468
- definition = definition.sub(Substitution.build([], [], instance_type: instance_type))
469
- definition = definition.map_method_type do |method_type|
470
- s = Substitution.build(
471
- method_type.free_variables.to_a,
472
- method_type.free_variables.map { Types::Bases::Any.new(location: nil) }
473
- )
474
- method_type.sub(s)
247
+ Definition.new(type_name: type_name, entry: entry, self_type: self_type, ancestors: ancestors).tap do |definition|
248
+ one_ancestors = ancestor_builder.one_singleton_ancestors(type_name)
249
+
250
+ if super_class = one_ancestors.super_class
251
+ case super_class
252
+ when Definition::Ancestor::Instance
253
+ defn = build_instance(super_class.name)
254
+ merge_definition(src: defn,
255
+ dest: definition,
256
+ subst: Substitution.build(defn.type_params, super_class.args),
257
+ keep_super: true)
258
+ when Definition::Ancestor::Singleton
259
+ defn = build_singleton0(super_class.name)
260
+ merge_definition(src: defn, dest: definition, subst: Substitution.new, keep_super: true)
475
261
  end
476
-
477
- [
478
- ancestor,
479
- definition
480
- ]
481
262
  end
482
- end
483
-
484
- merge_definitions(type_name, definition_pairs, entry: entry, self_type: self_type, ancestors: ancestors)
485
- end
486
- end
487
- end
488
263
 
489
- def method_definition_members(type_name, entry, kind:)
490
- # @type var interface_methods: Hash[Symbol, [Definition::Method, AST::Members::t]]
491
- interface_methods = {}
492
- # @type var methods: Hash[Symbol, Array[[AST::Members::MethodDefinition, Definition::accessibility]]]
493
- methods = {}
494
-
495
- entry.decls.each do |d|
496
- each_member_with_accessibility(d.decl.members) do |member, accessibility|
497
- case member
498
- when AST::Members::MethodDefinition
499
- case kind
500
- when :singleton
501
- next unless member.singleton?
502
- when :instance
503
- next unless member.instance?
264
+ one_ancestors.extended_modules.each do |mod|
265
+ defn = build_instance(mod.name)
266
+ merge_definition(src: defn,
267
+ dest: definition,
268
+ subst: Substitution.build(defn.type_params, mod.args))
504
269
  end
505
270
 
506
- methods[member.name] ||= []
507
- methods[member.name] << [
508
- member.update(types: member.types),
509
- accessibility
510
- ]
511
- when AST::Members::Include, AST::Members::Extend
512
- if member.name.interface?
513
- if (kind == :instance && member.is_a?(AST::Members::Include)) || (kind == :singleton && member.is_a?(AST::Members::Extend))
514
- NoMixinFoundError.check!(member.name, env: env, member: member)
515
-
516
- interface_name = member.name
517
- interface_args = member.args
518
-
519
- interface_definition = build_interface(interface_name)
520
-
521
- InvalidTypeApplicationError.check!(
522
- type_name: interface_name,
523
- args: interface_args,
524
- params: interface_definition.type_params_decl,
525
- location: member.location
526
- )
527
-
528
- sub = Substitution.build(interface_definition.type_params, interface_args)
529
-
530
- interface_definition.methods.each do |name, method|
531
- interface_methods[name] = [method.sub(sub), member]
271
+ interface_methods = {}
272
+ one_ancestors.extended_interfaces.each do |mod|
273
+ defn = build_interface(mod.name)
274
+ subst = Substitution.build(defn.type_params, mod.args)
275
+
276
+ defn.methods.each do |name, method|
277
+ if interface_methods.key?(name)
278
+ raise DuplicatedInterfaceMethodDefinitionError.new(
279
+ type: self_type,
280
+ method_name: name,
281
+ member: mod.source
282
+ )
532
283
  end
284
+
285
+ merge_method(type_name, interface_methods, name, method, subst, implemented_in: type_name)
533
286
  end
534
287
  end
535
- end
536
- end
537
- end
538
-
539
- # @type var result: Hash[Symbol, member_detail]
540
- result = {}
541
288
 
542
- interface_methods.each do |name, pair|
543
- method_definition, _ = pair
544
- # @type var detail: member_detail
545
- detail = [:public, method_definition, nil, []]
546
- result[name] = detail
547
- end
548
-
549
- methods.each do |method_name, array|
550
- if result[method_name]
551
- unless array.all? {|pair| pair[0].overload? }
552
- raise MethodDefinitionConflictWithInterfaceMixinError.new(
553
- type_name: type_name,
554
- method_name: method_name,
555
- kind: :instance,
556
- mixin_member: interface_methods[method_name][1],
557
- entries: array.map(&:first)
558
- )
559
- end
560
-
561
- unless array.all? {|pair| pair[1] == :public }
562
- raise InconsistentMethodVisibilityError.new(
563
- type_name: type_name,
564
- method_name: method_name,
565
- kind: :instance,
566
- member_pairs: array
567
- )
568
- end
569
-
570
- result[method_name][3].push(*array.map(&:first))
571
- else
572
- case
573
- when array.size == 1 && !array[0][0].overload?
574
- member, visibility = array[0]
575
- result[method_name] = [visibility, nil, member, []]
289
+ methods = method_builder.build_singleton(type_name)
290
+ define_methods(definition, interface_methods: interface_methods, methods: methods, super_interface_method: false)
291
+
292
+ entry.decls.each do |d|
293
+ d.decl.members.each do |member|
294
+ case member
295
+ when AST::Members::AttrReader, AST::Members::AttrAccessor, AST::Members::AttrWriter
296
+ if member.kind == :singleton
297
+ ivar_name = case member.ivar_name
298
+ when false
299
+ nil
300
+ else
301
+ member.ivar_name || :"@#{member.name}"
302
+ end
303
+
304
+ if ivar_name
305
+ insert_variable(type_name, definition.instance_variables, name: ivar_name, type: member.type)
306
+ end
307
+ end
576
308
 
577
- else
578
- visibilities = array.group_by {|pair| pair[1] }
309
+ when AST::Members::ClassInstanceVariable
310
+ insert_variable(type_name, definition.instance_variables, name: member.name, type: member.type)
579
311
 
580
- if visibilities.size > 1
581
- raise InconsistentMethodVisibilityError.new(
582
- type_name: type_name,
583
- method_name: method_name,
584
- kind: :instance,
585
- member_pairs: array
586
- )
312
+ when AST::Members::ClassVariable
313
+ insert_variable(type_name, definition.class_variables, name: member.name, type: member.type)
314
+ end
315
+ end
587
316
  end
588
-
589
- overloads, primary = array.map(&:first).partition(&:overload?)
590
- result[method_name] = [array[0][1], nil, primary[0], overloads]
591
317
  end
592
318
  end
593
319
  end
594
-
595
- result
596
320
  end
597
321
 
598
- def build_one_instance(type_name)
599
- try_cache(type_name, cache: one_instance_cache) do
600
- entry = env.class_decls[type_name]
601
-
602
- param_names = entry.type_params.each.map(&:name)
603
- self_type = Types::ClassInstance.new(name: type_name,
604
- args: Types::Variable.build(param_names),
605
- location: nil)
606
- ancestors = Definition::InstanceAncestors.new(
607
- type_name: type_name,
608
- params: param_names,
609
- ancestors: [Definition::Ancestor::Instance.new(name: type_name, args: self_type.args)]
610
- )
611
-
612
- Definition.new(type_name: type_name, entry: entry, self_type: self_type, ancestors: ancestors).tap do |definition|
613
- method_definition_members(type_name, entry, kind: :instance).each do |method_name, array|
614
- visibility, method_def, primary_member, overload_members = array
615
-
616
- members = if primary_member
617
- [primary_member, *overload_members]
618
- else
619
- overload_members
620
- end
322
+ def build_singleton(type_name)
323
+ try_cache type_name, cache: singleton_cache do
324
+ entry = env.class_decls[type_name] or raise "Unknown name for build_singleton: #{type_name}"
325
+ ensure_namespace!(type_name.namespace, location: entry.decls[0].decl.location)
621
326
 
622
- m = if method_def
623
- Definition::Method.new(
624
- super_method: nil,
625
- accessibility: visibility,
626
- defs: method_def.defs.map {|defn| defn.update(implemented_in: type_name) },
627
- alias_of: nil
628
- )
629
- else
630
- Definition::Method.new(
631
- super_method: nil,
632
- accessibility: visibility,
633
- defs: [],
634
- alias_of: nil
635
- )
636
- end
327
+ case entry
328
+ when Environment::ClassEntry, Environment::ModuleEntry
329
+ ancestors = ancestor_builder.singleton_ancestors(type_name)
330
+ self_type = Types::ClassSingleton.new(name: type_name, location: nil)
331
+ instance_type = Types::ClassInstance.new(
332
+ name: type_name,
333
+ args: entry.type_params.each.map { Types::Bases::Any.new(location: nil) },
334
+ location: nil
335
+ )
637
336
 
638
- definition.methods[method_name] = members.inject(m) do |original, member|
639
- defs = member.types.map do |method_type|
640
- Definition::Method::TypeDef.new(
641
- type: method_type,
642
- member: member,
643
- implemented_in: type_name,
644
- defined_in: type_name
645
- )
646
- end
337
+ Definition.new(type_name: type_name, entry: entry, self_type: self_type, ancestors: ancestors).tap do |definition|
338
+ def0 = build_singleton0(type_name)
339
+ subst = Substitution.build([], [], instance_type: instance_type)
647
340
 
648
- Definition::Method.new(
649
- super_method: nil,
650
- defs: defs + original.defs,
651
- accessibility: original.accessibility,
652
- alias_of: nil
653
- )
654
- end
655
- end
341
+ merge_definition(src: def0, dest: definition, subst: subst, keep_super: true)
656
342
 
657
- entry.decls.each do |d|
658
- each_member_with_accessibility(d.decl.members) do |member, accessibility|
659
- case member
660
- when AST::Members::AttrReader, AST::Members::AttrAccessor, AST::Members::AttrWriter
661
- if member.kind == :instance
662
- build_attribute(
663
- type_name: type_name,
664
- definition: definition,
665
- member: member,
666
- accessibility: accessibility
667
- )
668
- end
343
+ if entry.is_a?(Environment::ClassEntry)
344
+ new_method = definition.methods[:new]
345
+ if new_method.defs.all? {|d| d.defined_in == BuiltinNames::Class.name }
346
+ # The method is _untyped new_.
669
347
 
670
- when AST::Members::InstanceVariable
671
- definition.instance_variables[member.name] = Definition::Variable.new(
672
- parent_variable: nil,
673
- type: member.type,
674
- declared_in: type_name
675
- )
348
+ instance = build_instance(type_name)
349
+ initialize = instance.methods[:initialize]
676
350
 
677
- when AST::Members::ClassVariable
678
- definition.class_variables[member.name] = Definition::Variable.new(
679
- parent_variable: nil,
680
- type: member.type,
681
- declared_in: type_name
682
- )
351
+ if initialize
352
+ class_params = entry.type_params.each.map(&:name)
683
353
 
684
- end
685
- end
686
- end
354
+ # Inject a virtual _typed new_.
355
+ initialize_defs = initialize.defs
356
+ definition.methods[:new] = Definition::Method.new(
357
+ super_method: new_method,
358
+ defs: initialize_defs.map do |initialize_def|
359
+ method_type = initialize_def.type
687
360
 
688
- entry.decls.each do |d|
689
- d.decl.members.each do |member|
690
- case member
691
- when AST::Members::Alias
692
- if member.instance?
693
- UnknownMethodAliasError.check!(
694
- methods: definition.methods,
695
- original_name: member.old_name,
696
- aliased_name: member.new_name,
697
- location: member.location
698
- )
361
+ class_type_param_vars = Set.new(class_params)
362
+ method_type_param_vars = Set.new(method_type.type_params)
699
363
 
700
- DuplicatedMethodDefinitionError.check!(
701
- decl: d.decl,
702
- methods: definition.methods,
703
- name: member.new_name,
704
- location: member.location
705
- )
364
+ if class_type_param_vars.intersect?(method_type_param_vars)
365
+ renamed_method_params = method_type.type_params.map do |name|
366
+ if class_type_param_vars.include?(name)
367
+ Types::Variable.fresh(name).name
368
+ else
369
+ name
370
+ end
371
+ end
372
+ method_params = class_params + renamed_method_params
706
373
 
707
- original_method = definition.methods[member.old_name]
374
+ sub = Substitution.build(method_type.type_params, Types::Variable.build(renamed_method_params))
375
+ else
376
+ method_params = class_params + method_type.type_params
377
+ sub = Substitution.build([], [])
378
+ end
708
379
 
709
- definition.methods[member.new_name] = Definition::Method.new(
710
- super_method: original_method.super_method,
711
- defs: original_method.defs,
712
- accessibility: original_method.accessibility,
713
- alias_of: original_method,
714
- annotations: original_method.annotations
380
+ method_type = method_type.map_type {|ty| ty.sub(sub) }
381
+ method_type = method_type.update(
382
+ type_params: method_params,
383
+ type: method_type.type.with_return_type(
384
+ Types::ClassInstance.new(
385
+ name: type_name,
386
+ args: Types::Variable.build(entry.type_params.each.map(&:name)),
387
+ location: nil
388
+ )
389
+ )
390
+ )
391
+
392
+ Definition::Method::TypeDef.new(
393
+ type: method_type,
394
+ member: initialize_def.member,
395
+ defined_in: initialize_def.defined_in,
396
+ implemented_in: initialize_def.implemented_in
397
+ )
398
+ end,
399
+ accessibility: :public,
400
+ annotations: [],
401
+ alias_of: nil
715
402
  )
716
403
  end
717
404
  end
718
405
  end
719
406
  end
720
-
721
- entry.decls.each do |d|
722
- validate_parameter_variance(
723
- decl: d.decl,
724
- methods: definition.methods
725
- )
726
- end
727
407
  end
728
408
  end
729
409
  end
@@ -738,349 +418,302 @@ module RBS
738
418
  end
739
419
  end
740
420
 
741
- def validate_parameter_variance(decl:, methods:)
742
- type_params = decl.type_params
421
+ def validate_type_params(definition, ancestors:, methods:)
422
+ type_params = definition.type_params_decl
743
423
 
744
424
  calculator = VarianceCalculator.new(builder: self)
745
425
  param_names = type_params.each.map(&:name)
746
426
 
747
- errors = []
748
-
749
- case decl
750
- when AST::Declarations::Class
751
- if super_class = decl.super_class
752
- result = calculator.in_inherit(name: super_class.name, args: super_class.args, variables: param_names)
753
-
754
- validate_params_with type_params, result: result do |param|
755
- errors.push InvalidVarianceAnnotationError::InheritanceError.new(
756
- param: param
427
+ ancestors.each_ancestor do |ancestor|
428
+ case ancestor
429
+ when Definition::Ancestor::Instance
430
+ result = calculator.in_inherit(name: ancestor.name, args: ancestor.args, variables: param_names)
431
+ validate_params_with(type_params, result: result) do |param|
432
+ location = case source = ancestor.source
433
+ when nil
434
+ definition.entry.primary.decl.location
435
+ when :super
436
+ definition.entry.primary.decl.super_class.location
437
+ else
438
+ source.location
439
+ end
440
+
441
+ raise InvalidVarianceAnnotationError.new(
442
+ type_name: definition.type_name,
443
+ param: param,
444
+ location: location
757
445
  )
758
446
  end
759
447
  end
760
448
  end
761
449
 
762
- # @type var result: VarianceCalculator::Result
763
-
764
- decl.members.each do |member|
765
- case member
766
- when AST::Members::Include
767
- if member.name.class?
768
- result = calculator.in_inherit(name: member.name, args: member.args, variables: param_names)
769
-
770
- validate_params_with type_params, result: result do |param|
771
- errors.push InvalidVarianceAnnotationError::MixinError.new(
772
- include_member: member,
773
- param: param
774
- )
775
- end
776
- end
777
- end
778
- end
779
-
780
- methods.each do |name, method|
781
- method.method_types.each do |method_type|
782
- unless name == :initialize
450
+ methods.each do |defn|
451
+ next if defn.name == :initialize
452
+
453
+ method_types = case original = defn.original
454
+ when AST::Members::MethodDefinition
455
+ original.types
456
+ when AST::Members::AttrWriter, AST::Members::AttrReader, AST::Members::AttrAccessor
457
+ if defn.name.to_s.end_with?("=")
458
+ [
459
+ MethodType.new(
460
+ type_params: [],
461
+ type: Types::Function.empty(original.type).update(
462
+ required_positionals: [
463
+ Types::Function::Param.new(type: original.type, name: original.name)
464
+ ]
465
+ ),
466
+ block: nil,
467
+ location: original.location
468
+ )
469
+ ]
470
+ else
471
+ [
472
+ MethodType.new(
473
+ type_params: [],
474
+ type: Types::Function.empty(original.type),
475
+ block: nil,
476
+ location: original.location
477
+ )
478
+ ]
479
+ end
480
+ when AST::Members::Alias
481
+ nil
482
+ when nil
483
+ nil
484
+ else
485
+ raise
486
+ end
487
+
488
+ if method_types
489
+ method_types.each do |method_type|
783
490
  result = calculator.in_method_type(method_type: method_type, variables: param_names)
784
-
785
- validate_params_with type_params, result: result do |param|
786
- errors.push InvalidVarianceAnnotationError::MethodTypeError.new(
787
- method_name: name,
788
- method_type: method_type,
789
- param: param
491
+ validate_params_with(type_params, result: result) do |param|
492
+ raise InvalidVarianceAnnotationError.new(
493
+ type_name: definition.type_name,
494
+ param: param,
495
+ location: method_type.location
790
496
  )
791
497
  end
792
498
  end
793
499
  end
794
500
  end
795
-
796
- unless errors.empty?
797
- raise InvalidVarianceAnnotationError.new(decl: decl, errors: errors)
798
- end
799
501
  end
800
502
 
801
- def build_one_singleton(type_name)
802
- try_cache(type_name, cache: one_singleton_cache) do
803
- entry = env.class_decls[type_name]
804
-
805
- self_type = Types::ClassSingleton.new(name: type_name, location: nil)
806
- ancestors = Definition::SingletonAncestors.new(
807
- type_name: type_name,
808
- ancestors: [Definition::Ancestor::Singleton.new(name: type_name)]
809
- )
503
+ def insert_variable(type_name, variables, name:, type:)
504
+ variables[name] = Definition::Variable.new(
505
+ parent_variable: variables[name],
506
+ type: type,
507
+ declared_in: type_name
508
+ )
509
+ end
810
510
 
811
- Definition.new(type_name: type_name, entry: entry, self_type: self_type, ancestors: ancestors).tap do |definition|
812
- method_definition_members(type_name, entry, kind: :singleton).each do |method_name, array|
813
- visibility, method_def, primary_member, overload_members = array
511
+ def define_methods(definition, interface_methods:, methods:, super_interface_method:)
512
+ methods.each do |method_def|
513
+ method_name = method_def.name
514
+ original = method_def.original
814
515
 
815
- members = if primary_member
816
- [primary_member, *overload_members]
817
- else
818
- overload_members
819
- end
516
+ if original.is_a?(AST::Members::Alias)
517
+ existing_method = interface_methods[method_name] || definition.methods[method_name]
518
+ original_method = interface_methods[original.old_name] || definition.methods[original.old_name]
820
519
 
821
- m = Definition::Method.new(
822
- super_method: nil,
823
- defs: method_def&.yield_self do |method_def|
824
- method_def.defs.map {|defn| defn.update(implemented_in: type_name) }
825
- end || [],
826
- accessibility: visibility,
827
- alias_of: nil
520
+ unless original_method
521
+ raise UnknownMethodAliasError.new(
522
+ original_name: original.old_name,
523
+ aliased_name: original.new_name,
524
+ location: original.location
828
525
  )
829
- definition.methods[method_name] = members.inject(m) do |original, new|
830
- defs = new.types.map do |type|
831
- Definition::Method::TypeDef.new(
832
- type: type,
833
- member: new,
834
- defined_in: type_name,
835
- implemented_in: type_name
836
- )
837
- end
838
- Definition::Method.new(
839
- super_method: nil,
840
- defs: defs + original.defs,
841
- accessibility: original.accessibility,
842
- alias_of: nil
843
- )
844
- end
845
526
  end
846
527
 
847
- entry.decls.each do |d|
848
- d.decl.members.each do |member|
849
- case member
850
- when AST::Members::Alias
851
- if member.singleton?
852
- UnknownMethodAliasError.check!(
853
- methods: definition.methods,
854
- original_name: member.old_name,
855
- aliased_name: member.new_name,
856
- location: member.location
857
- )
858
-
859
- DuplicatedMethodDefinitionError.check!(
860
- decl: d.decl,
861
- methods: definition.methods,
862
- name: member.new_name,
863
- location: member.location
864
- )
528
+ method = Definition::Method.new(
529
+ super_method: existing_method,
530
+ defs: original_method.defs.map do |defn|
531
+ defn.update(defined_in: definition.type_name, implemented_in: definition.type_name)
532
+ end,
533
+ accessibility: method_def.accessibility,
534
+ alias_of: original_method
535
+ )
536
+ else
537
+ if interface_methods.key?(method_name)
538
+ interface_method = interface_methods[method_name]
865
539
 
866
- original_method = definition.methods[member.old_name]
867
- definition.methods[member.new_name] = Definition::Method.new(
868
- super_method: original_method.super_method,
869
- defs: original_method.defs,
870
- accessibility: original_method.accessibility,
871
- alias_of: original_method,
872
- annotations: original_method.annotations
873
- )
874
- end
875
- end
540
+ if method_def.original
541
+ raise DuplicatedMethodDefinitionError.new(
542
+ type: definition.self_type,
543
+ method_name: method_name,
544
+ members: [method_def.original]
545
+ )
876
546
  end
877
- end
878
547
 
879
- unless definition.methods.key?(:new)
880
- instance = build_instance(type_name)
881
- initialize = instance.methods[:initialize]
548
+ definition.methods[method_name] = interface_method
549
+ end
882
550
 
883
- if initialize
884
- class_params = entry.type_params.each.map(&:name)
551
+ existing_method = definition.methods[method_name]
885
552
 
886
- initialize_defs = initialize.defs
887
- definition.methods[:new] = Definition::Method.new(
888
- super_method: nil,
889
- defs: initialize_defs.map do |initialize_def|
890
- method_type = initialize_def.type
553
+ case original
554
+ when AST::Members::MethodDefinition
555
+ defs = original.types.map do |method_type|
556
+ Definition::Method::TypeDef.new(
557
+ type: method_type,
558
+ member: original,
559
+ defined_in: definition.type_name,
560
+ implemented_in: definition.type_name
561
+ )
562
+ end
891
563
 
892
- class_type_param_vars = Set.new(class_params)
893
- method_type_param_vars = Set.new(method_type.type_params)
564
+ accessibility = if method_name == :initialize
565
+ :private
566
+ else
567
+ method_def.accessibility
568
+ end
894
569
 
895
- if class_type_param_vars.intersect?(method_type_param_vars)
896
- renamed_method_params = method_type.type_params.map do |name|
897
- if class_type_param_vars.include?(name)
898
- Types::Variable.fresh(name).name
899
- else
900
- name
901
- end
902
- end
903
- method_params = class_params + renamed_method_params
570
+ method = Definition::Method.new(
571
+ super_method: existing_method,
572
+ defs: defs,
573
+ accessibility: accessibility,
574
+ alias_of: nil
575
+ )
904
576
 
905
- sub = Substitution.build(method_type.type_params, Types::Variable.build(renamed_method_params))
906
- else
907
- method_params = class_params + method_type.type_params
908
- sub = Substitution.build([], [])
909
- end
577
+ when AST::Members::AttrReader, AST::Members::AttrWriter, AST::Members::AttrAccessor
578
+ method_type = if method_name.to_s.end_with?("=")
579
+ # setter
580
+ MethodType.new(
581
+ type_params: [],
582
+ type: Types::Function.empty(original.type).update(
583
+ required_positionals: [
584
+ Types::Function::Param.new(type: original.type, name: original.name)
585
+ ]
586
+ ),
587
+ block: nil,
588
+ location: nil
589
+ )
590
+ else
591
+ # getter
592
+ MethodType.new(
593
+ type_params: [],
594
+ type: Types::Function.empty(original.type),
595
+ block: nil,
596
+ location: nil
597
+ )
598
+ end
599
+ defs = [
600
+ Definition::Method::TypeDef.new(
601
+ type: method_type,
602
+ member: original,
603
+ defined_in: definition.type_name,
604
+ implemented_in: definition.type_name
605
+ )
606
+ ]
910
607
 
911
- method_type = method_type.map_type {|ty| ty.sub(sub) }
912
- method_type = method_type.update(
913
- type_params: method_params,
914
- type: method_type.type.with_return_type(Types::Bases::Instance.new(location: nil))
915
- )
608
+ method = Definition::Method.new(
609
+ super_method: existing_method,
610
+ defs: defs,
611
+ accessibility: method_def.accessibility,
612
+ alias_of: nil
613
+ )
916
614
 
917
- Definition::Method::TypeDef.new(
918
- type: method_type,
919
- member: initialize_def.member,
920
- defined_in: initialize_def.defined_in,
921
- implemented_in: initialize_def.implemented_in
922
- )
923
- end,
924
- accessibility: :public,
925
- annotations: [AST::Annotation.new(location: nil, string: "rbs:test:target")],
926
- alias_of: nil
615
+ when nil
616
+ unless definition.methods.key?(method_name)
617
+ raise InvalidOverloadMethodError.new(
618
+ type_name: definition.type_name,
619
+ method_name: method_name,
620
+ kind: :instance,
621
+ members: method_def.overloads
927
622
  )
928
623
  end
929
- end
930
624
 
931
- entry.decls.each do |d|
932
- each_member_with_accessibility(d.decl.members) do |member, accessibility|
933
- case member
934
- when AST::Members::AttrReader, AST::Members::AttrAccessor, AST::Members::AttrWriter
935
- if member.kind == :singleton
936
- build_attribute(type_name: type_name,
937
- definition: definition,
938
- member: member,
939
- accessibility: accessibility)
940
- end
941
-
942
- when AST::Members::ClassInstanceVariable
943
- definition.instance_variables[member.name] = Definition::Variable.new(
944
- parent_variable: nil,
945
- type: member.type,
946
- declared_in: type_name
947
- )
948
-
949
- when AST::Members::ClassVariable
950
- definition.class_variables[member.name] = Definition::Variable.new(
951
- parent_variable: nil,
952
- type: member.type,
953
- declared_in: type_name
954
- )
955
- end
625
+ if !super_interface_method && existing_method.defs.any? {|defn| defn.defined_in.interface? }
626
+ super_method = existing_method.super_method
627
+ else
628
+ super_method = existing_method
956
629
  end
630
+
631
+ method = Definition::Method.new(
632
+ super_method: super_method,
633
+ defs: existing_method.defs.map do |defn|
634
+ defn.update(implemented_in: definition.type_name)
635
+ end,
636
+ accessibility: existing_method.accessibility,
637
+ alias_of: existing_method.alias_of
638
+ )
957
639
  end
958
640
  end
959
- end
960
- end
961
641
 
962
- def build_attribute(type_name:, definition:, member:, accessibility:)
963
- name = member.name
964
- type = member.type
965
-
966
- ivar_name = case member.ivar_name
967
- when false
968
- nil
969
- else
970
- member.ivar_name || :"@#{member.name}"
971
- end
972
-
973
- if member.is_a?(AST::Members::AttrReader) || member.is_a?(AST::Members::AttrAccessor)
974
- definition.methods[name] = Definition::Method.new(
975
- super_method: nil,
976
- defs: [
642
+ method_def.overloads.each do |overload|
643
+ defs = overload.types.map do |method_type|
977
644
  Definition::Method::TypeDef.new(
978
- type: MethodType.new(
979
- type_params: [],
980
- type: Types::Function.empty(type),
981
- block: nil,
982
- location: nil
983
- ),
984
- member: member,
985
- defined_in: type_name,
986
- implemented_in: type_name
645
+ type: method_type,
646
+ member: overload,
647
+ defined_in: definition.type_name,
648
+ implemented_in: definition.type_name
987
649
  )
988
- ],
989
- accessibility: accessibility,
990
- alias_of: nil
991
- )
992
- end
650
+ end
993
651
 
994
- if member.is_a?(AST::Members::AttrWriter) || member.is_a?(AST::Members::AttrAccessor)
995
- definition.methods[:"#{name}="] = Definition::Method.new(
996
- super_method: nil,
997
- defs: [
998
- Definition::Method::TypeDef.new(
999
- type: MethodType.new(
1000
- type_params: [],
1001
- type: Types::Function.empty(type).update(
1002
- required_positionals: [Types::Function::Param.new(name: name, type: type)]
1003
- ),
1004
- block: nil,
1005
- location: nil
1006
- ),
1007
- member: member,
1008
- defined_in: type_name,
1009
- implemented_in: type_name
1010
- ),
1011
- ],
1012
- accessibility: accessibility,
1013
- alias_of: nil
1014
- )
652
+ method.defs.unshift(*defs)
653
+ end
654
+
655
+ definition.methods[method_name] = method
1015
656
  end
1016
657
 
1017
- if ivar_name
1018
- definition.instance_variables[ivar_name] = Definition::Variable.new(
1019
- parent_variable: nil,
1020
- type: type,
1021
- declared_in: type_name
1022
- )
658
+ interface_methods.each do |name, method|
659
+ unless methods.methods.key?(name)
660
+ merge_method(definition.type_name, definition.methods, name, method, Substitution.new)
661
+ end
1023
662
  end
1024
663
  end
1025
664
 
1026
- def merge_definitions(type_name, pairs, entry:, self_type:, ancestors:)
1027
- Definition.new(type_name: type_name, entry: entry, self_type: self_type, ancestors: ancestors).tap do |definition|
1028
- pairs.reverse_each do |ancestor, current_definition|
1029
- sub = case ancestor
1030
- when Definition::Ancestor::Instance
1031
- Substitution.build(current_definition.type_params, ancestor.args)
1032
- when Definition::Ancestor::Singleton
1033
- Substitution.build([], [])
1034
- end
1035
-
1036
- # @type var kind: method_kind
1037
- kind = case ancestor
1038
- when Definition::Ancestor::Instance
1039
- :instance
1040
- when Definition::Ancestor::Singleton
1041
- :singleton
1042
- end
1043
-
1044
- current_definition.methods.each do |name, method|
1045
- merge_method type_name, definition.methods, name, method, sub, kind: kind
1046
- end
665
+ def merge_definition(src:, dest:, subst:, implemented_in: :keep, keep_super: false)
666
+ src.methods.each do |name, method|
667
+ merge_method(dest.type_name, dest.methods, name, method, subst, implemented_in: implemented_in, keep_super: keep_super)
668
+ end
1047
669
 
1048
- current_definition.instance_variables.each do |name, variable|
1049
- merge_variable definition.instance_variables, name, variable
1050
- end
670
+ src.instance_variables.each do |name, variable|
671
+ merge_variable(dest.instance_variables, name, variable, subst, keep_super: keep_super)
672
+ end
1051
673
 
1052
- current_definition.class_variables.each do |name, variable|
1053
- merge_variable definition.class_variables, name, variable
1054
- end
1055
- end
674
+ src.class_variables.each do |name, variable|
675
+ merge_variable(dest.class_variables, name, variable, subst, keep_super: keep_super)
1056
676
  end
1057
677
  end
1058
678
 
1059
- def merge_variable(variables, name, variable)
679
+ def merge_variable(variables, name, variable, sub, keep_super: false)
1060
680
  super_variable = variables[name]
1061
681
 
1062
682
  variables[name] = Definition::Variable.new(
1063
- parent_variable: super_variable,
1064
- type: variable.type,
683
+ parent_variable: keep_super ? variable.parent_variable : super_variable,
684
+ type: sub.empty? ? variable.type : variable.type.sub(sub),
1065
685
  declared_in: variable.declared_in
1066
686
  )
1067
687
  end
1068
688
 
1069
- def merge_method(type_name, methods, name, method, sub, kind:)
1070
- super_method = methods[name]
689
+ def merge_method(type_name, methods, name, method, sub, implemented_in: :keep, keep_super: false)
690
+ defs = method.defs.yield_self do |defs|
691
+ if sub.empty? && implemented_in == :keep
692
+ defs
693
+ else
694
+ defs.map do |defn|
695
+ defn.update(
696
+ type: sub.empty? ? defn.type : defn.type.sub(sub),
697
+ implemented_in: case implemented_in
698
+ when :keep
699
+ defn.implemented_in
700
+ when nil
701
+ nil
702
+ else
703
+ implemented_in
704
+ end
705
+ )
706
+ end
707
+ end
708
+ end
1071
709
 
1072
- defs = if method.defs.all? {|d| d.overload? }
1073
- raise InvalidOverloadMethodError.new(type_name: type_name, method_name: name, kind: kind, members: method.members) unless super_method
1074
- method.defs + super_method.defs
1075
- else
1076
- method.defs
1077
- end
710
+ super_method = methods[name]
1078
711
 
1079
712
  methods[name] = Definition::Method.new(
1080
- super_method: super_method,
713
+ super_method: keep_super ? method.super_method : super_method,
1081
714
  accessibility: method.accessibility,
1082
- defs: sub.mapping.empty? ? defs : defs.map {|defn| defn.update(type: defn.type.sub(sub)) },
1083
- alias_of: nil
715
+ defs: defs,
716
+ alias_of: method.alias_of
1084
717
  )
1085
718
  end
1086
719
 
@@ -1105,103 +738,6 @@ module RBS
1105
738
  end
1106
739
  end
1107
740
 
1108
- def build_interface(type_name)
1109
- try_cache(type_name, cache: interface_cache) do
1110
- entry = env.interface_decls[type_name] or raise "Unknown name for build_interface: #{type_name}"
1111
- declaration = entry.decl
1112
- ensure_namespace!(type_name.namespace, location: declaration.location)
1113
-
1114
- self_type = Types::Interface.new(
1115
- name: type_name,
1116
- args: Types::Variable.build(declaration.type_params.each.map(&:name)),
1117
- location: nil
1118
- )
1119
-
1120
- Definition.new(type_name: type_name, entry: entry, self_type: self_type, ancestors: nil).tap do |definition|
1121
- include_members = []
1122
- def_members = []
1123
- alias_members = []
1124
-
1125
- declaration.members.each do |member|
1126
- case member
1127
- when AST::Members::Include
1128
- include_members << member
1129
- when AST::Members::MethodDefinition
1130
- def_members << member
1131
- when AST::Members::Alias
1132
- alias_members << member
1133
- end
1134
- end
1135
-
1136
- include_members.each do |member|
1137
- NoMixinFoundError.check!(member.name, env: env, member: member)
1138
-
1139
- mixin = build_interface(member.name)
1140
-
1141
- args = member.args
1142
- # @type var interface_entry: Environment::SingleEntry[TypeName, AST::Declarations::Interface]
1143
- interface_entry = _ = mixin.entry
1144
- type_params = interface_entry.decl.type_params
1145
-
1146
- InvalidTypeApplicationError.check!(
1147
- type_name: type_name,
1148
- args: args,
1149
- params: type_params.each.map(&:name),
1150
- location: member.location
1151
- )
1152
-
1153
- sub = Substitution.build(type_params.each.map(&:name), args)
1154
- mixin.methods.each do |name, method|
1155
- definition.methods[name] = method.sub(sub)
1156
- end
1157
- end
1158
-
1159
- def_members.each do |member|
1160
- DuplicatedMethodDefinitionError.check!(
1161
- decl: declaration,
1162
- methods: definition.methods,
1163
- name: member.name,
1164
- location: member.location
1165
- )
1166
-
1167
- method = Definition::Method.new(
1168
- super_method: nil,
1169
- defs: member.types.map do |method_type|
1170
- Definition::Method::TypeDef.new(
1171
- type: method_type,
1172
- member: member,
1173
- defined_in: type_name,
1174
- implemented_in: nil
1175
- )
1176
- end,
1177
- accessibility: :public,
1178
- alias_of: nil
1179
- )
1180
- definition.methods[member.name] = method
1181
- end
1182
-
1183
- alias_members.each do |member|
1184
- UnknownMethodAliasError.check!(
1185
- methods: definition.methods,
1186
- original_name: member.old_name,
1187
- aliased_name: member.new_name,
1188
- location: member.location
1189
- )
1190
-
1191
- DuplicatedMethodDefinitionError.check!(
1192
- decl: declaration,
1193
- methods: definition.methods,
1194
- name: member.new_name,
1195
- location: member.location
1196
- )
1197
-
1198
- # FIXME: may cause a problem if #old_name has super type
1199
- definition.methods[member.new_name] = definition.methods[member.old_name]
1200
- end
1201
- end
1202
- end
1203
- end
1204
-
1205
741
  def expand_alias(type_name)
1206
742
  entry = env.alias_decls[type_name] or raise "Unknown name for expand_alias: #{type_name}"
1207
743
  ensure_namespace!(type_name.namespace, location: entry.decl.location)