rbs 3.6.1 → 3.9.5

data/lib/rbs/definition_builder.rb

@@ -82,7 +82,7 @@ module RBS
       AST::TypeParam.application(params, args) || Substitution.new()
     end
 
-    def define_instance(definition, type_name, subst)
+    def define_instance(definition, type_name, subst, define_class_vars:)
       one_ancestors = ancestor_builder.one_instance_ancestors(type_name)
       methods = method_builder.build_instance(type_name)
 
@@ -104,7 +104,7 @@ module RBS
           validate_type_presence(arg)
         end
 
-        define_instance(definition, mod.name, subst + tapp_subst(mod.name, mod.args))
+        define_instance(definition, mod.name, subst + tapp_subst(mod.name, mod.args), define_class_vars: define_class_vars)
       end
 
       all_interfaces = one_ancestors.each_included_interface.flat_map do |interface|
@@ -120,7 +120,7 @@ module RBS
           validate_type_presence(arg)
         end
 
-        define_instance(definition, mod.name, subst + tapp_subst(mod.name, mod.args))
+        define_instance(definition, mod.name, subst + tapp_subst(mod.name, mod.args), define_class_vars: define_class_vars)
       end
 
       entry = env.class_decls[type_name] or raise "Unknown name for build_instance: #{type_name}"
@@ -145,7 +145,8 @@ module RBS
                   type_name,
                   definition.instance_variables,
                   name: ivar_name,
-                  type: member.type.sub(subst_)
+                  type: member.type.sub(subst_),
+                  source: member
                 )
               end
             end
@@ -155,11 +156,14 @@ module RBS
               type_name,
               definition.instance_variables,
               name: member.name,
-              type: member.type.sub(subst_)
+              type: member.type.sub(subst_),
+              source: member
             )
 
           when AST::Members::ClassVariable
-            insert_variable(type_name, definition.class_variables, name: member.name, type: member.type)
+            if define_class_vars
+              insert_variable(type_name, definition.class_variables, name: member.name, type: member.type, source: member)
+            end
           end
         end
       end
@@ -214,13 +218,13 @@ module RBS
                 if ans.name.interface?
                   define_interface(definition, ans.name, subst)
                 else
-                  define_instance(definition, ans.name, subst)
+                  define_instance(definition, ans.name, subst, define_class_vars: true)
                 end
               end
             end
           end
 
-          define_instance(definition, type_name, Substitution.new)
+          define_instance(definition, type_name, Substitution.new, define_class_vars: true)
         end
       end
     end
@@ -249,7 +253,6 @@ module RBS
 
             definition.methods.merge!(defn.methods)
             definition.instance_variables.merge!(defn.instance_variables)
-            definition.class_variables.merge!(defn.class_variables)
           end
 
           one_ancestors.each_extended_module do |mod|
@@ -258,7 +261,7 @@ module RBS
             end
 
             subst = tapp_subst(mod.name, mod.args)
-            define_instance(definition, mod.name, subst)
+            define_instance(definition, mod.name, subst, define_class_vars: false)
           end
 
           all_interfaces = one_ancestors.each_extended_interface.flat_map do |interface|
@@ -282,18 +285,18 @@ module RBS
                               end
 
                   if ivar_name
-                    insert_variable(type_name, definition.instance_variables, name: ivar_name, type: member.type)
+                    insert_variable(type_name, definition.instance_variables, name: ivar_name, type: member.type, source: member)
                   end
                 end
 
               when AST::Members::ClassInstanceVariable
-                insert_variable(type_name, definition.instance_variables, name: member.name, type: member.type)
-
-              when AST::Members::ClassVariable
-                insert_variable(type_name, definition.class_variables, name: member.name, type: member.type)
+                insert_variable(type_name, definition.instance_variables, name: member.name, type: member.type, source: member)
               end
             end
           end
+
+          instance_definition = build_instance(type_name)
+          definition.class_variables.replace(instance_definition.class_variables)
         end
       end
     end
@@ -387,10 +390,13 @@ module RBS
                       member: initialize_def.member,
                       defined_in: initialize_def.defined_in,
                       implemented_in: initialize_def.implemented_in
-                    )
+                    ).tap do |type_def|
+                      type_def.overload_annotations.replace(initialize_def.overload_annotations)
+                    end
                   end,
                   accessibility: :public,
-                  alias_of: nil
+                  alias_of: nil,
+                  alias_member: nil
                 )
 
                 definition.methods[:new] = typed_new
@@ -534,12 +540,42 @@ module RBS
       end
     end
 
-    def insert_variable(type_name, variables, name:, type:)
+    def insert_variable(type_name, variables, name:, type:, source:)
       variables[name] = Definition::Variable.new(
         parent_variable: variables[name],
         type: type,
-        declared_in: type_name
+        declared_in: type_name,
+        source: source
       )
+      validate_variable(variables[name])
+    end
+
+    def validate_variable(var)
+      return unless var.parent_variable
+
+      # Ignore attrs
+      variables = [] #: Array[Definition::Variable]
+      tmp_var = var
+      while tmp_var
+        variables << tmp_var if tmp_var.source.is_a?(AST::Members::Var)
+        tmp_var = tmp_var.parent_variable
+      end
+
+      # Duplicates should be eliminated, so there can't be more than 3.
+      return unless variables.length == 2
+
+      l, r = variables #: [Definition::Variable, Definition::Variable]
+
+      case l.source
+      when AST::Members::InstanceVariable
+        if r.source.instance_of?(AST::Members::InstanceVariable) && l.declared_in == r.declared_in
+          raise InstanceVariableDuplicationError.new(type_name: l.declared_in, variable_name: l.source.name, location: l.source.location)
+        end
+      when AST::Members::ClassInstanceVariable
+        if r.source.instance_of?(AST::Members::ClassInstanceVariable) && l.declared_in == r.declared_in
+          raise ClassInstanceVariableDuplicationError.new(type_name: l.declared_in, variable_name: l.source.name, location: l.source.location)
+        end
+      end
     end
 
     def import_methods(definition, module_name, module_methods, interfaces_methods, subst, self_type_methods)
@@ -625,8 +661,11 @@ module RBS
             defn.update(defined_in: defined_in, implemented_in: implemented_in)
           end,
           accessibility: original_method.accessibility,
-          alias_of: original_method
+          alias_of: original_method,
+          alias_member: original
         )
+
+        method_definition.annotations.replace(original.annotations)
       when AST::Members::MethodDefinition
         if duplicated_method = methods[method.name]
           raise DuplicatedMethodDefinitionError.new(
@@ -642,7 +681,10 @@ module RBS
             member: original,
             defined_in: defined_in,
             implemented_in: implemented_in
-          )
+          ).tap do |type_def|
+            # Keep the original annotations given to overloads.
+            type_def.overload_annotations.replace(overload.annotations)
+          end
         end
 
         # @type var accessibility: RBS::Definition::accessibility
@@ -662,8 +704,11 @@ module RBS
           super_method: super_method,
           defs: defs,
           accessibility: accessibility,
-          alias_of: nil
+          alias_of: nil,
+          alias_member: nil
         )
+
+        method_definition.annotations.replace(original.annotations)
       when AST::Members::AttrReader, AST::Members::AttrWriter, AST::Members::AttrAccessor
         if duplicated_method = methods[method.name]
           raise DuplicatedMethodDefinitionError.new(
@@ -712,8 +757,11 @@ module RBS
             )
           ],
           accessibility: method.accessibility,
-          alias_of: nil
+          alias_of: nil,
+          alias_member: nil
         )
+
+        method_definition.annotations.replace(original.annotations)
       when nil
         # Overloading method definition only
 
@@ -740,8 +788,11 @@ module RBS
             defn.update(implemented_in: implemented_in)
           end,
           accessibility: existing_method.accessibility,
-          alias_of: existing_method.alias_of
+          alias_of: existing_method.alias_of,
+          alias_member: nil
         )
+
+        method_definition.annotations.replace(existing_method.annotations)
       end
 
       method.overloads.each do |overloading_def|
@@ -753,8 +804,16 @@ module RBS
             implemented_in: implemented_in
           )
 
+          type_def.overload_annotations.replace(overload.annotations)
+
           method_definition.defs.unshift(type_def)
         end
+
+        method_definition.annotations.concat(overloading_def.annotations)
+      end
+
+      method_definition.defs.each do |type_def|
+        type_def.member_annotations.replace(method_definition.annotations)
       end
 
       methods[method.name] = method_definition

data/lib/rbs/environment.rb

@@ -486,6 +486,28 @@ module RBS
       end
     end
 
+    def resolve_signature(resolver, table, dirs, decls, only: nil)
+      map = UseMap.new(table: table)
+      dirs.each do |dir|
+        case dir
+        when AST::Directives::Use
+          dir.clauses.each do |clause|
+            map.build_map(clause)
+          end
+        end
+      end
+
+      decls = decls.map do |decl|
+        if only && !only.member?(decl)
+          decl
+        else
+          resolve_declaration(resolver, map, decl, outer: [], prefix: Namespace.root)
+        end
+      end
+
+      [dirs, decls]
+    end
+
     def resolve_type_names(only: nil)
       resolver = Resolver::TypeNameResolver.new(self)
       env = Environment.new
@@ -498,21 +520,10 @@ module RBS
       table.compute_children
 
       signatures.each do |buffer, (dirs, decls)|
-        map = UseMap.new(table: table)
-        dirs.each do |dir|
-          dir.clauses.each do |clause|
-            map.build_map(clause)
-          end
-        end
-
-        decls = decls.map do |decl|
-          if only && !only.member?(decl)
-            decl
-          else
-            resolve_declaration(resolver, map, decl, outer: [], prefix: Namespace.root)
-          end
+        resolve = dirs.find { _1.is_a?(AST::Directives::ResolveTypeNames) } #: AST::Directives::ResolveTypeNames?
+        if !resolve || resolve.value
+          _, decls = resolve_signature(resolver, table, dirs, decls)
         end
-
         env.add_signature(buffer: buffer, directives: dirs, decls: decls)
       end
 
@@ -541,7 +552,8 @@ module RBS
           name: decl.name,
           type: absolute_type(resolver, map, decl.type, context: nil),
           location: decl.location,
-          comment: decl.comment
+          comment: decl.comment,
+          annotations: decl.annotations
         )
       end
 
@@ -649,7 +661,8 @@ module RBS
           name: decl.name.with_prefix(prefix),
           type: absolute_type(resolver, map, decl.type, context: context),
           location: decl.location,
-          comment: decl.comment
+          comment: decl.comment,
+          annotations: decl.annotations
         )
 
       when AST::Declarations::ClassAlias
@@ -657,7 +670,8 @@ module RBS
           new_name: decl.new_name.with_prefix(prefix),
           old_name: absolute_type_name(resolver, map, decl.old_name, context: context),
           location: decl.location,
-          comment: decl.comment
+          comment: decl.comment,
+          annotations: decl.annotations
         )
 
       when AST::Declarations::ModuleAlias
@@ -665,7 +679,8 @@ module RBS
           new_name: decl.new_name.with_prefix(prefix),
           old_name: absolute_type_name(resolver, map, decl.old_name, context: context),
           location: decl.location,
-          comment: decl.comment
+          comment: decl.comment,
+          annotations: decl.annotations
         )
       end
     end

data/lib/rbs/environment_loader.rb

@@ -26,7 +26,7 @@ module RBS
     DEFAULT_CORE_ROOT = Pathname(_ = __dir__) + "../../core"
 
     def self.gem_sig_path(name, version)
-      requirements = []
+      requirements = [] #: Array[String]
       requirements << version if version
       spec = Gem::Specification.find_by_name(name, *requirements)
       path = Pathname(spec.gem_dir) + "sig"
@@ -113,6 +113,11 @@ module RBS
       # @type var loaded: Array[[AST::Declarations::t, Pathname, source]]
       loaded = []
 
+      # For migrating stringio to stdlib
+      if @core_root && libs.none? { |lib| lib.name == 'stringio' }
+        add(library: 'stringio', version: nil)
+      end
+
       each_signature do |source, path, buffer, decls, dirs|
         decls.each do |decl|
           loaded << [decl, path, source]

data/lib/rbs/errors.rb

@@ -322,6 +322,30 @@ module RBS
     end
   end
 
+  class VariableDuplicationError < DefinitionError
+    include DetailedMessageable
+
+    attr_reader :type_name
+    attr_reader :variable_name
+    attr_reader :location
+
+    def initialize(type_name:, variable_name:, location:)
+      @type_name = type_name
+      @variable_name = variable_name
+      @location = location
+
+      super "#{Location.to_string location}: Duplicated #{kind} variable name `#{variable_name}` in `#{type_name}`"
+    end
+  end
+
+  class InstanceVariableDuplicationError < VariableDuplicationError
+    def kind = 'instance'
+  end
+
+  class ClassInstanceVariableDuplicationError < VariableDuplicationError
+    def kind = 'class instance'
+  end
+
   class UnknownMethodAliasError < DefinitionError
     include DetailedMessageable
 

data/lib/rbs/locator.rb

@@ -40,6 +40,8 @@ module RBS
     end
 
     def find_in_directive(pos, dir, array)
+      return false unless dir.is_a?(AST::Directives::Use)
+
       if test_loc(pos, location: dir.location)
         array.unshift(dir)
 

data/lib/rbs/method_type.rb

@@ -33,6 +33,8 @@ module RBS
     def sub(s)
       sub = s.without(*type_param_names)
 
+      return self if sub.empty?
+
       self.class.new(
         type_params: type_params.map do |param|
           param.map_type do |bound|

data/lib/rbs/namespace.rb

@@ -119,6 +119,7 @@ end
 
 module Kernel
   def Namespace(name)
+    warn "Kernel#Namespace() is deprecated. Use RBS::Namespace.parse instead.", category: :deprecated
     RBS::Namespace.parse(name)
   end
 end

data/lib/rbs/parser_aux.rb

@@ -17,11 +17,48 @@ module RBS
 
     def self.parse_signature(source)
       buf = buffer(source)
-      dirs, decls = _parse_signature(buf, buf.last_position)
+
+      resolved = magic_comment(buf)
+      start_pos =
+        if resolved
+          (resolved.location || raise).end_pos
+        else
+          0
+        end
+      dirs, decls = _parse_signature(buf, start_pos, buf.last_position)
+
+      if resolved
+        dirs = dirs.dup if dirs.frozen?
+        dirs.unshift(resolved)
+      end
 
       [buf, dirs, decls]
     end
 
+    def self.magic_comment(buf)
+      start_pos = 0
+
+      while true
+        case
+        when match = /\A#\s*(?<keyword>resolve-type-names)\s*(?<colon>:)\s+(?<value>true|false)$/.match(buf.content, start_pos)
+          value = match[:value] or raise
+
+          kw_offset = match.offset(:keyword) #: [Integer, Integer]
+          colon_offset = match.offset(:colon) #: [Integer, Integer]
+          value_offset = match.offset(:value) #: [Integer, Integer]
+
+          location = Location.new(buf, kw_offset[0], value_offset[1])
+          location.add_required_child(:keyword, kw_offset[0]...kw_offset[1])
+          location.add_required_child(:colon, colon_offset[0]...colon_offset[1])
+          location.add_required_child(:value, value_offset[0]...value_offset[1])
+
+          return AST::Directives::ResolveTypeNames.new(value: value == "true", location: location)
+        else
+          return
+        end
+      end
+    end
+
     def self.lex(source)
       buf = buffer(source)
       list = _lex(buf, buf.last_position)
@@ -70,8 +107,8 @@ module RBS
       untyped
       true
       false
-      ).each_with_object({}) do |keyword, hash|
-        hash[keyword] = nil
+      ).each_with_object({}) do |keyword, hash| #$ Hash[String, bot]
+        hash[keyword] = _ = nil
       end
   end
 end

data/lib/rbs/prototype/rb.rb

@@ -75,8 +75,8 @@ module RBS
       def parse(string)
         # @type var comments: Hash[Integer, AST::Comment]
         comments = Ripper.lex(string).yield_self do |tokens|
-          code_lines = {}
-          tokens.each.with_object({}) do |token, hash|
+          code_lines = {} #: Hash[Integer, bool]
+          tokens.each.with_object({}) do |token, hash| #$ Hash[Integer, AST::Comment]
             case token[1]
             when :on_sp, :on_ignored_nl
               # skip
@@ -368,7 +368,7 @@ module RBS
                        when node.children[0].is_a?(Symbol)
                          TypeName.new(name: node.children[0], namespace: Namespace.empty)
                        else
-                         const_to_name!(node.children[0])
+                         const_to_name!(node.children[0], context: context)
                        end
 
           value_node = node.children.last
@@ -382,7 +382,8 @@ module RBS
             name: const_name,
             type: type,
             location: nil,
-            comment: comments[node.first_lineno - 1]
+            comment: comments[node.first_lineno - 1],
+            annotations: []
           )
 
         when :IASGN
@@ -429,13 +430,13 @@ module RBS
         end
       end
 
-      def const_to_name!(node)
+      def const_to_name!(node, context: nil)
         case node.type
         when :CONST
           TypeName.new(name: node.children[0], namespace: Namespace.empty)
         when :COLON2
           if node.children[0]
-            namespace = const_to_name!(node.children[0]).to_namespace
+            namespace = const_to_name!(node.children[0], context: context).to_namespace
           else
             namespace = Namespace.empty
           end
@@ -443,6 +444,10 @@ module RBS
           TypeName.new(name: node.children[1], namespace: namespace)
         when :COLON3
           TypeName.new(name: node.children[0], namespace: Namespace.root)
+        when :SELF
+          raise if context.nil?
+
+          context.namespace.to_type_name
         else
           raise
         end
@@ -639,11 +644,11 @@ module RBS
             children = list.children
             children.pop
           else
-            children = []
+            children = [] #: Array[untyped]
           end
 
-          key_types = []
-          value_types = []
+          key_types = [] #: Array[Types::t]
+          value_types = [] #: Array[Types::t]
           children.each_slice(2) do |k, v|
             if k
               key_types << literal_to_type(k)
@@ -655,7 +660,10 @@ module RBS
           end
 
           if !key_types.empty? && key_types.all? { |t| t.is_a?(Types::Literal) }
-            fields = key_types.map { |t| t.literal }.zip(value_types).to_h
+            fields = key_types.map {|t|
+              t.is_a?(Types::Literal) or raise
+              t.literal
+            }.zip(value_types).to_h #: Hash[Types::Literal::literal, Types::t]
             Types::Record.new(fields: fields, location: nil)
           else
             key_type = types_to_union_type(key_types)
@@ -715,9 +723,9 @@ module RBS
         when :FLOAT
           BuiltinNames::Float.instance_type
         when :RATIONAL
-          Types::ClassInstance.new(name: TypeName("::Rational"), args: [], location: nil)
+          Types::ClassInstance.new(name: TypeName.parse("::Rational"), args: [], location: nil)
         when :IMAGINARY
-          Types::ClassInstance.new(name: TypeName("::Complex"), args: [], location: nil)
+          Types::ClassInstance.new(name: TypeName.parse("::Complex"), args: [], location: nil)
         when :LIT
           case node.children[0]
           when Symbol

data/lib/rbs/prototype/rbi.rb

@@ -17,9 +17,7 @@ module RBS
 
       def parse(string)
         comments = Ripper.lex(string).yield_self do |tokens|
-          tokens.each.with_object({}) do |token, hash|
-            # @type var hash: Hash[Integer, AST::Comment]
-
+          tokens.each.with_object({}) do |token, hash| #$ Hash[Integer, AST::Comment]
             if token[1] == :on_comment
               line = token[0][0]
               body = token[2][2..-1] or raise
@@ -259,7 +257,8 @@ module RBS
               name: name,
               type: type,
               location: nil,
-              comment: nil
+              comment: nil,
+              annotations: []
             )
           end
         when :ALIAS
@@ -325,11 +324,17 @@ module RBS
               end
             end
           when :type_parameters
-            type_params = []
+            type_params = [] #: Array[AST::TypeParam]
 
             each_arg args do |node|
               if name = symbol_literal_node?(node)
-                type_params << name
+                type_params << AST::TypeParam.new(
+                  name: name,
+                  variance: :invariant,
+                  upper_bound: nil,
+                  location: nil,
+                  default_type: nil
+                )
               end
             end
 

data/lib/rbs/prototype/runtime/value_object_generator.rb

@@ -80,7 +80,9 @@ module RBS
               kind: :instance,
               location: nil,
               comment: nil,
-              annotations: []
+              annotations: (
+                [] #: Array[AST::Annotation]
+              )
             )
           end
         end
@@ -100,7 +102,7 @@ module RBS
         CAN_CALL_KEYWORD_INIT_P = Struct.new(:tmp).respond_to?(:keyword_init?)
 
         def build_super_class
-          AST::Declarations::Class::Super.new(name: TypeName("::Struct"), args: [untyped], location: nil)
+          AST::Declarations::Class::Super.new(name: TypeName.parse("::Struct"), args: [untyped], location: nil)
         end
 
         def add_decl_members(decl)
@@ -114,7 +116,7 @@ module RBS
         #             | (?foo: untyped, ?bar: untyped) -> instance
         def build_s_new
           [:new, :[]].map do |name|
-            new_overloads = []
+            new_overloads = [] #: Array[AST::Members::MethodDefinition::Overload]
 
             if CAN_CALL_KEYWORD_INIT_P
               case @target_class.keyword_init?
@@ -221,7 +223,7 @@ module RBS
         private
 
         def build_super_class
-          AST::Declarations::Class::Super.new(name: TypeName("::Data"), args: [], location: nil)
+          AST::Declarations::Class::Super.new(name: TypeName.parse("::Data"), args: [], location: nil)
         end
 
         def add_decl_members(decl)
@@ -234,7 +236,7 @@ module RBS
         #             | (foo: untyped, bar: untyped) -> instance
         def build_s_new
           [:new, :[]].map do |name|
-            new_overloads = []
+            new_overloads = [] #: Array[AST::Members::MethodDefinition::Overload]
 
             new_overloads << AST::Members::MethodDefinition::Overload.new(
               annotations: [],