lib/rbs/definition_builder.rb in rbs-0.11.0 vs lib/rbs/definition_builder.rb in rbs-0.12.0
- old
+ new
@@ -34,12 +34,15 @@
@prepended_modules = prepended_modules
@extended_modules = extended_modules
end
def each_ancestor(&block)
- if block_given?
- yield super_class if super_class
+ if block
+ if s = super_class
+ yield s
+ end
+
self_types&.each(&block)
included_modules&.each(&block)
prepended_modules&.each(&block)
extended_modules&.each(&block)
else
@@ -106,11 +109,11 @@
with_super_classes = entry.decls.select {|d| d.decl.super_class }
return if with_super_classes.size <= 1
super_types = with_super_classes.map do |d|
- super_class = d.decl.super_class
+ super_class = d.decl.super_class or raise
Types::ClassInstance.new(name: super_class.name, args: super_class.args, location: nil)
end
super_types.uniq!
@@ -157,14 +160,14 @@
when Environment::ModuleEntry
ancestors = OneAncestors.module_instance(type_name: type_name, params: params)
entry.self_types.each do |module_self|
NoSelfTypeFoundError.check!(module_self, env: env)
- ancestors.self_types.push Definition::Ancestor::Instance.new(name: module_self.name, args: module_self.args)
+
+ self_types = ancestors.self_types or raise
+ self_types.push Definition::Ancestor::Instance.new(name: module_self.name, args: module_self.args)
end
- else
- raise "Unexpected entry for: #{type_name}"
end
mixin_ancestors(entry,
included_modules: ancestors.included_modules,
prepended_modules: ancestors.prepended_modules,
@@ -206,13 +209,10 @@
when Environment::ModuleEntry
ancestors = OneAncestors.singleton(
type_name: type_name,
super_class: Definition::Ancestor::Instance.new(name: BuiltinNames::Module.name, args: [])
)
-
- else
- raise "Unexpected entry for: #{type_name}"
end
mixin_ancestors(entry,
included_modules: nil,
prepended_modules: nil,
@@ -283,37 +283,42 @@
ancestors = []
case entry
when Environment::ClassEntry
- if one_ancestors.super_class
- super_name = one_ancestors.super_class.name
- super_args = one_ancestors.super_class.args
+ if super_class = one_ancestors.super_class
+ # @type var super_class: Definition::Ancestor::Instance
+ super_name = super_class.name
+ super_args = super_class.args
super_ancestors = instance_ancestors(super_name, building_ancestors: building_ancestors)
ancestors.unshift(*super_ancestors.apply(super_args, location: entry.primary.decl.location))
end
end
- one_ancestors.included_modules.each do |mod|
- if mod.name.class?
- name = mod.name
- args = mod.args
- mod_ancestors = instance_ancestors(name, building_ancestors: building_ancestors)
- ancestors.unshift(*mod_ancestors.apply(args, location: entry.primary.decl.location))
- end
+ if included_modules = one_ancestors.included_modules
+ included_modules.each do |mod|
+ if mod.name.class?
+ name = mod.name
+ arg_types = mod.args
+ mod_ancestors = instance_ancestors(name, building_ancestors: building_ancestors)
+ ancestors.unshift(*mod_ancestors.apply(arg_types, location: entry.primary.decl.location))
+ end
+ end
end
ancestors.unshift(self_ancestor)
- one_ancestors.prepended_modules.each do |mod|
- if mod.name.class?
- name = mod.name
- args = mod.args
- mod_ancestors = instance_ancestors(name, building_ancestors: building_ancestors)
- ancestors.unshift(*mod_ancestors.apply(args, location: entry.primary.decl.location))
- end
+ if prepended_modules = one_ancestors.prepended_modules
+ prepended_modules.each do |mod|
+ if mod.name.class?
+ name = mod.name
+ arg_types = mod.args
+ mod_ancestors = instance_ancestors(name, building_ancestors: building_ancestors)
+ ancestors.unshift(*mod_ancestors.apply(arg_types, location: entry.primary.decl.location))
+ end
+ end
end
building_ancestors.pop
instance_ancestors_cache[type_name] = Definition::InstanceAncestors.new(
@@ -336,26 +341,27 @@
one_ancestors = one_singleton_ancestors(type_name)
ancestors = []
- case one_ancestors.super_class
+ case super_class = one_ancestors.super_class
when Definition::Ancestor::Instance
- super_name = one_ancestors.super_class.name
- super_args = one_ancestors.super_class.args
+ super_name = super_class.name
+ super_args = super_class.args
super_ancestors = instance_ancestors(super_name, building_ancestors: building_ancestors)
ancestors.unshift(*super_ancestors.apply(super_args, location: entry.primary.decl.location))
when Definition::Ancestor::Singleton
- super_name = one_ancestors.super_class.name
+ super_name = super_class.name
super_ancestors = singleton_ancestors(super_name, building_ancestors: [])
ancestors.unshift(*super_ancestors.ancestors)
end
- one_ancestors.extended_modules.each do |mod|
+ extended_modules = one_ancestors.extended_modules or raise
+ extended_modules.each do |mod|
if mod.name.class?
name = mod.name
args = mod.args
mod_ancestors = instance_ancestors(name, building_ancestors: building_ancestors)
ancestors.unshift(*mod_ancestors.apply(args, location: entry.primary.decl.location))
@@ -404,21 +410,21 @@
self_type = Types::ClassInstance.new(name: type_name,
args: Types::Variable.build(entry.type_params.each.map(&:name)),
location: nil)
definition_pairs = ancestors.ancestors.map do |ancestor|
+ # @type block: [Definition::Ancestor::t, Definition]
case ancestor
when Definition::Ancestor::Instance
[ancestor, build_one_instance(ancestor.name)]
when Definition::Ancestor::Singleton
[ancestor, build_one_singleton(ancestor.name)]
- else
- raise
end
end
- if entry.is_a?(Environment::ModuleEntry)
+ case entry
+ when Environment::ModuleEntry
entry.self_types.each do |module_self|
ancestor = Definition::Ancestor::Instance.new(name: module_self.name, args: module_self.args)
definition_pairs.push(
[
ancestor,
@@ -431,13 +437,10 @@
)
end
end
merge_definitions(type_name, definition_pairs, entry: entry, self_type: self_type, ancestors: ancestors)
-
- else
- raise
end
end
end
def build_singleton(type_name)
@@ -454,10 +457,11 @@
args: Types::Variable.build(entry.type_params.each.map(&:name)),
location: nil
)
definition_pairs = ancestors.ancestors.map do |ancestor|
+ # @type block: [Definition::Ancestor::t, Definition]
case ancestor
when Definition::Ancestor::Instance
[ancestor, build_one_instance(ancestor.name)]
when Definition::Ancestor::Singleton
definition = build_one_singleton(ancestor.name)
@@ -472,24 +476,22 @@
[
ancestor,
definition
]
- else
- raise
end
end
merge_definitions(type_name, definition_pairs, entry: entry, self_type: self_type, ancestors: ancestors)
- else
- raise
end
end
end
def method_definition_members(type_name, entry, kind:)
+ # @type var interface_methods: Hash[Symbol, [Definition::Method, AST::Members::t]]
interface_methods = {}
+ # @type var methods: Hash[Symbol, Array[[AST::Members::MethodDefinition, Definition::accessibility]]]
methods = {}
entry.decls.each do |d|
each_member_with_accessibility(d.decl.members) do |member, accessibility|
case member
@@ -532,15 +534,18 @@
end
end
end
end
+ # @type var result: Hash[Symbol, member_detail]
result = {}
interface_methods.each do |name, pair|
method_definition, _ = pair
- result[name] = [:public, method_definition]
+ # @type var detail: member_detail
+ detail = [:public, method_definition, nil, []]
+ result[name] = detail
end
methods.each do |method_name, array|
if result[method_name]
unless array.all? {|pair| pair[0].overload? }
@@ -560,16 +565,16 @@
kind: :instance,
member_pairs: array
)
end
- result[method_name] += array.map(&:first)
+ result[method_name][3].push(*array.map(&:first))
else
case
when array.size == 1 && !array[0][0].overload?
member, visibility = array[0]
- result[method_name] = [visibility, nil, member]
+ result[method_name] = [visibility, nil, member, []]
else
visibilities = array.group_by {|pair| pair[1] }
if visibilities.size > 1
@@ -580,11 +585,11 @@
member_pairs: array
)
end
overloads, primary = array.map(&:first).partition(&:overload?)
- result[method_name] = [array[0][1], nil, *primary, *overloads]
+ result[method_name] = [array[0][1], nil, primary[0], overloads]
end
end
end
result
@@ -599,12 +604,18 @@
location: nil)
ancestors = [Definition::Ancestor::Instance.new(name: type_name, args: self_type.args)]
Definition.new(type_name: type_name, entry: entry, self_type: self_type, ancestors: ancestors).tap do |definition|
method_definition_members(type_name, entry, kind: :instance).each do |method_name, array|
- visibility, method_def, *members = array
+ visibility, method_def, primary_member, overload_members = array
+ members = if primary_member
+ [primary_member, *overload_members]
+ else
+ overload_members
+ end
+
m = if method_def
Definition::Method.new(
super_method: nil,
accessibility: visibility,
defs: method_def.defs.map {|defn| defn.update(implemented_in: type_name) }
@@ -768,23 +779,25 @@
calculator = VarianceCalculator.new(builder: self)
param_names = type_params.each.map(&:name)
errors = []
- if decl.is_a?(AST::Declarations::Class)
- if decl.super_class
- super_class = decl.super_class
+ case decl
+ when AST::Declarations::Class
+ if super_class = decl.super_class
result = calculator.in_inherit(name: super_class.name, args: super_class.args, variables: param_names)
validate_params_with type_params, result: result do |param|
errors.push InvalidVarianceAnnotationError::InheritanceError.new(
param: param
)
end
end
end
+ # @type var result: VarianceCalculator::Result
+
decl.members.each do |member|
case member
when AST::Members::Include
if member.name.class?
result = calculator.in_inherit(name: member.name, args: member.args, variables: param_names)
@@ -828,12 +841,18 @@
self_type = Types::ClassSingleton.new(name: type_name, location: nil)
ancestors = [Definition::Ancestor::Singleton.new(name: type_name)]
Definition.new(type_name: type_name, entry: entry, self_type: self_type, ancestors: ancestors).tap do |definition|
method_definition_members(type_name, entry, kind: :singleton).each do |method_name, array|
- visibility, method_def, *members = array
+ visibility, method_def, primary_member, overload_members = array
+ members = if primary_member
+ [primary_member, *overload_members]
+ else
+ overload_members
+ end
+
m = Definition::Method.new(
super_method: nil,
defs: method_def&.yield_self do |method_def|
method_def.defs.map {|defn| defn.update(implemented_in: type_name) }
end || [],
@@ -880,11 +899,11 @@
end
end
end
unless definition.methods.key?(:new)
- instance = build_one_instance(type_name)
+ instance = build_instance(type_name)
initialize = instance.methods[:initialize]
if initialize
class_params = entry.type_params.each.map(&:name)
@@ -955,18 +974,19 @@
end
end
def merge_definitions(type_name, pairs, entry:, self_type:, ancestors:)
Definition.new(type_name: type_name, entry: entry, self_type: self_type, ancestors: ancestors).tap do |definition|
- pairs.reverse_each do |(ancestor, current_definition)|
+ pairs.reverse_each do |ancestor, current_definition|
sub = case ancestor
when Definition::Ancestor::Instance
Substitution.build(current_definition.type_params, ancestor.args)
when Definition::Ancestor::Singleton
Substitution.build([], [])
end
+ # @type var kind: method_kind
kind = case ancestor
when Definition::Ancestor::Instance
:instance
when Definition::Ancestor::Singleton
:singleton
@@ -1013,11 +1033,11 @@
defs: sub.mapping.empty? ? defs : defs.map {|defn| defn.update(type: defn.type.sub(sub)) }
)
end
def try_cache(type_name, cache:)
- cached = cache[type_name]
+ cached = _ = cache[type_name]
case cached
when Definition
cached
when false
@@ -1025,13 +1045,15 @@
when nil
cache[type_name] = false
begin
cache[type_name] = yield
rescue => ex
- cache[type_name] = nil
+ cache.delete(type_name)
raise ex
end
+ else
+ raise
end
end
def build_interface(type_name)
try_cache(type_name, cache: interface_cache) do
@@ -1065,10 +1087,12 @@
NoMixinFoundError.check!(member.name, env: env, member: member)
mixin = build_interface(member.name)
args = member.args
- type_params = mixin.entry.decl.type_params
+ # @type var interface_entry: Environment::SingleEntry[TypeName, AST::Declarations::Interface]
+ interface_entry = _ = mixin.entry
+ type_params = interface_entry.decl.type_params
InvalidTypeApplicationError.check!(
type_name: type_name,
args: args,
params: type_params.each.map(&:name),