rbs 0.8.0 → 0.12.0

data/lib/rbs/definition_builder.rb

@@ -36,8 +36,11 @@ module RBS
       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)
@@ -108,7 +111,7 @@ module RBS
       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
 
@@ -159,10 +162,10 @@ module RBS
 
         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,
@@ -208,9 +211,6 @@ module RBS
           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,
@@ -285,33 +285,38 @@ module RBS
 
       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
@@ -338,22 +343,23 @@ module RBS
 
       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
@@ -385,9 +391,18 @@ module RBS
       end
     end
 
+    def ensure_namespace!(namespace, location:)
+      namespace.ascend do |ns|
+        unless ns.empty?
+          NoTypeFoundError.check!(ns.to_type_name, env: env, location: location)
+        end
+      end
+    end
+
     def build_instance(type_name)
       try_cache type_name, cache: instance_cache do
         entry = env.class_decls[type_name] or raise "Unknown name for build_instance: #{type_name}"
+        ensure_namespace!(type_name.namespace, location: entry.decls[0].decl.location)
 
         case entry
         when Environment::ClassEntry, Environment::ModuleEntry
@@ -397,17 +412,17 @@ module RBS
                                                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(
@@ -424,9 +439,6 @@ module RBS
           end
 
           merge_definitions(type_name, definition_pairs, entry: entry, self_type: self_type, ancestors: ancestors)
-
-        else
-          raise
         end
       end
     end
@@ -434,6 +446,7 @@ module RBS
     def build_singleton(type_name)
       try_cache type_name, cache: singleton_cache do
         entry = env.class_decls[type_name] or raise "Unknown name for build_singleton: #{type_name}"
+        ensure_namespace!(type_name.namespace, location: entry.decls[0].decl.location)
 
         case entry
         when Environment::ClassEntry, Environment::ModuleEntry
@@ -446,6 +459,7 @@ module RBS
           )
 
           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)]
@@ -464,20 +478,18 @@ module RBS
                 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|
@@ -524,11 +536,14 @@ module RBS
         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|
@@ -552,14 +567,14 @@ module RBS
             )
           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, []]
 
-          when array.count {|pair| !pair[0].overload? } == 1
+          else
             visibilities = array.group_by {|pair| pair[1] }
 
             if visibilities.size > 1
@@ -572,15 +587,7 @@ module RBS
             end
 
             overloads, primary = array.map(&:first).partition(&:overload?)
-            result[method_name] = [array[0][1], nil, *primary, *overloads]
-
-          else
-            raise InvalidOverloadMethodError.new(
-              type_name: type_name,
-              method_name: method_name,
-              kind: :instance,
-              members: array.map(&:first)
-            )
+            result[method_name] = [array[0][1], nil, primary[0], overloads]
           end
         end
       end
@@ -599,7 +606,13 @@ module RBS
 
         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(
@@ -768,9 +781,9 @@ module RBS
 
       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|
@@ -781,6 +794,8 @@ module RBS
         end
       end
 
+      # @type var result: VarianceCalculator::Result
+
       decl.members.each do |member|
         case member
         when AST::Members::Include
@@ -828,7 +843,13 @@ module RBS
 
         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,
@@ -880,7 +901,7 @@ module RBS
           end
 
           unless definition.methods.key?(:new)
-            instance = build_one_instance(type_name)
+            instance = build_instance(type_name)
             initialize = instance.methods[:initialize]
 
             if initialize
@@ -924,7 +945,8 @@ module RBS
                     implemented_in: nil
                   )
                 end,
-                accessibility: :public
+                accessibility: :public,
+                annotations: [AST::Annotation.new(location: nil, string: "rbs:test:target")]
               )
             end
           end
@@ -954,7 +976,7 @@ module RBS
 
     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)
@@ -962,8 +984,16 @@ module RBS
                   Substitution.build([], [])
                 end
 
+          # @type var kind: method_kind
+          kind = case ancestor
+                 when Definition::Ancestor::Instance
+                   :instance
+                 when Definition::Ancestor::Singleton
+                   :singleton
+                 end
+
           current_definition.methods.each do |name, method|
-            merge_method definition.methods, name, method, sub
+            merge_method type_name, definition.methods, name, method, sub, kind: kind
           end
 
           current_definition.instance_variables.each do |name, variable|
@@ -987,18 +1017,25 @@ module RBS
       )
     end
 
-    def merge_method(methods, name, method, sub)
+    def merge_method(type_name, methods, name, method, sub, kind:)
       super_method = methods[name]
 
+      defs = if method.defs.all? {|d| d.overload? }
+               raise InvalidOverloadMethodError.new(type_name: type_name, method_name: name, kind: kind, members: method.members) unless super_method
+               method.defs + super_method.defs
+             else
+               method.defs
+             end
+
       methods[name] = Definition::Method.new(
         super_method: super_method,
         accessibility: method.accessibility,
-        defs: sub.mapping.empty? ? method.defs : method.defs.map {|defn| defn.update(type: defn.type.sub(sub)) }
+        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
@@ -1010,9 +1047,11 @@ module RBS
         begin
           cache[type_name] = yield
         rescue => ex
-          cache[type_name] = nil
+          cache.delete(type_name)
           raise ex
         end
+      else
+        raise
       end
     end
 
@@ -1020,6 +1059,7 @@ module RBS
       try_cache(type_name, cache: interface_cache) do
         entry = env.interface_decls[type_name] or raise "Unknown name for build_interface: #{type_name}"
         declaration = entry.decl
+        ensure_namespace!(type_name.namespace, location: declaration.location)
 
         self_type = Types::Interface.new(
           name: type_name,
@@ -1049,7 +1089,9 @@ module RBS
             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,
@@ -1111,6 +1153,7 @@ module RBS
 
     def expand_alias(type_name)
       entry = env.alias_decls[type_name] or raise "Unknown name for expand_alias: #{type_name}"
+      ensure_namespace!(type_name.namespace, location: entry.decl.location)
       entry.decl.type
     end
   end

data/lib/rbs/environment.rb

@@ -13,14 +13,15 @@ module RBS
       def context
         @context ||= begin
                        (outer + [decl]).each.with_object([Namespace.root]) do |decl, array|
-                         array.unshift(array.first + decl.name.to_namespace)
+                         first = array.first or raise 
+                         array.unshift(first + decl.name.to_namespace)
                        end
                      end
       end
     end
 
     class MultiEntry
-      D = Struct.new(:decl, :outer, keyword_init: true) do
+      D = _ = Struct.new(:decl, :outer, keyword_init: true) do
         include ContextUtil
       end
 
@@ -40,6 +41,8 @@ module RBS
       def validate_type_params
         unless decls.empty?
           hd_decl, *tl_decls = decls
+          raise unless hd_decl
+
           hd_params = hd_decl.decl.type_params
           hd_names = hd_params.params.map(&:name)
 
@@ -56,6 +59,10 @@ module RBS
       def type_params
         primary.decl.type_params
       end
+
+      def primary
+        raise "Not implemented"
+      end
     end
 
     class ModuleEntry < MultiEntry
@@ -68,7 +75,7 @@ module RBS
       def primary
         @primary ||= begin
                        validate_type_params
-                       decls.first
+                       decls.first or raise("decls cannot be empty")
                      end
       end
     end
@@ -77,7 +84,7 @@ module RBS
       def primary
         @primary ||= begin
                        validate_type_params
-                       decls.find {|d| d.decl.super_class } || decls.first
+                       decls.find {|d| d.decl.super_class } || decls.first or raise("decls cannot be empty")
                      end
       end
     end
@@ -154,15 +161,17 @@ module RBS
 
         case
         when decl.is_a?(AST::Declarations::Module) && existing_entry.is_a?(ModuleEntry)
-          # OK
+          # @type var existing_entry: ModuleEntry
+          # @type var decl: AST::Declarations::Module
+          existing_entry.insert(decl: decl, outer: outer)
         when decl.is_a?(AST::Declarations::Class) && existing_entry.is_a?(ClassEntry)
-          # OK
+          # @type var existing_entry: ClassEntry
+          # @type var decl: AST::Declarations::Class
+          existing_entry.insert(decl: decl, outer: outer)
         else
           raise DuplicatedDeclarationError.new(name, decl, existing_entry.primary.decl)
         end
 
-        existing_entry.insert(decl: decl, outer: outer)
-
         prefix = outer + [decl]
         ns = name.to_namespace
         decl.each_decl do |d|
@@ -211,6 +220,7 @@ module RBS
 
     def resolve_declaration(resolver, decl, outer:, prefix:)
       if decl.is_a?(AST::Declarations::Global)
+        # @type var decl: AST::Declarations::Global
         return AST::Declarations::Global.new(
           name: decl.name,
           type: absolute_type(resolver, decl.type, context: [Namespace.root]),
@@ -220,7 +230,8 @@ module RBS
       end
 
       context = (outer + [decl]).each.with_object([Namespace.root]) do |decl, array|
-        array.unshift(array.first + decl.name.to_namespace)
+        head = array.first or raise
+        array.unshift(head + decl.name.to_namespace)
       end
 
       case decl
@@ -310,6 +321,9 @@ module RBS
           location: decl.location,
           comment: decl.comment
         )
+
+      else
+        raise
       end
     end
 
@@ -325,7 +339,6 @@ module RBS
           comment: member.comment,
           overload: member.overload?,
           annotations: member.annotations,
-          attributes: member.attributes,
           location: member.location
         )
       when AST::Members::AttrAccessor
@@ -410,7 +423,7 @@ module RBS
     end
 
     def absolute_type(resolver, type, context:)
-      type.map_type_name do |name|
+      type.map_type_name do |name, _, _|
         absolute_type_name(resolver, name, context: context)
       end
     end