rbs 3.8.0 → 3.9.0.dev.1

data/lib/rbs/definition.rb

@@ -6,18 +6,23 @@ module RBS
       attr_reader :parent_variable
       attr_reader :type
       attr_reader :declared_in
+      attr_reader :source
 
-      def initialize(parent_variable:, type:, declared_in:)
+      def initialize(parent_variable:, type:, declared_in:, source:)
         @parent_variable = parent_variable
         @type = type
         @declared_in = declared_in
+        @source = source
       end
 
       def sub(s)
+        return self if s.empty?
+
         self.class.new(
           parent_variable: parent_variable,
           type: type.sub(s),
-          declared_in: declared_in
+          declared_in: declared_in,
+          source: source
         )
       end
     end
@@ -37,9 +42,9 @@ module RBS
           @member = member
           @defined_in = defined_in
           @implemented_in = implemented_in
-          @member_annotations = member.annotations
-          @overload_annotations = overload_annotations
-          @annotations = member.annotations + overload_annotations
+          @member_annotations = []
+          @overload_annotations = []
+          @annotations = []
         end
 
         def ==(other)
@@ -61,7 +66,10 @@ module RBS
         end
 
         def update(type: self.type, member: self.member, defined_in: self.defined_in, implemented_in: self.implemented_in)
-          TypeDef.new(type: type, member: member, defined_in: defined_in, implemented_in: implemented_in, overload_annotations: overload_annotations)
+          TypeDef.new(type: type, member: member, defined_in: defined_in, implemented_in: implemented_in).tap do |type_def|
+            type_def.overload_annotations.replace(self.overload_annotations)
+            type_def.member_annotations.replace(self.member_annotations)
+          end
         end
 
         def overload?
@@ -72,20 +80,33 @@ module RBS
             false
           end
         end
+
+        def each_annotation(&block)
+          if block
+            member_annotations.each(&block)
+            overload_annotations.each(&block)
+          else
+            enum_for :each_annotation
+          end
+        end
       end
 
       attr_reader :super_method
       attr_reader :defs
       attr_reader :accessibility
       attr_reader :extra_annotations
+      attr_reader :annotations
       attr_reader :alias_of
+      attr_reader :alias_member
 
-      def initialize(super_method:, defs:, accessibility:, annotations: [], alias_of:)
+      def initialize(super_method:, defs:, accessibility:, annotations: [], alias_of:, alias_member: nil)
         @super_method = super_method
         @defs = defs
         @accessibility = accessibility
         @extra_annotations = []
+        @annotations = []
         @alias_of = alias_of
+        @alias_member = alias_member
       end
 
       def ==(other)
@@ -94,7 +115,8 @@ module RBS
           other.defs == defs &&
           other.accessibility == accessibility &&
           other.annotations == annotations &&
-          other.alias_of == alias_of
+          other.alias_of == alias_of &&
+          other.alias_member == alias_member
       end
 
       alias eql? ==
@@ -125,10 +147,6 @@ module RBS
         @comments ||= defs.map(&:comment).compact.uniq
       end
 
-      def annotations
-        @annotations ||= defs.flat_map {|d| d.member_annotations }
-      end
-
       def members
         @members ||= defs.map(&:member).uniq
       end
@@ -142,49 +160,44 @@ module RBS
       end
 
       def sub(s)
-        self.class.new(
+        return self if s.empty?
+
+        update(
           super_method: super_method&.sub(s),
-          defs: defs.map {|defn| defn.update(type: defn.type.sub(s)) },
-          accessibility: @accessibility,
-          alias_of: alias_of
+          defs: defs.map {|defn| defn.update(type: defn.type.sub(s)) }
         )
       end
 
       def map_type(&block)
-        self.class.new(
+        update(
           super_method: super_method&.map_type(&block),
-          defs: defs.map {|defn| defn.update(type: defn.type.map_type(&block)) },
-          accessibility: @accessibility,
-          alias_of: alias_of
+          defs: defs.map {|defn| defn.update(type: defn.type.map_type(&block)) }
         )
       end
 
       def map_type_bound(&block)
-        self.class.new(
+        update(
           super_method: super_method&.map_type_bound(&block),
-          defs: defs.map {|defn| defn.update(type: defn.type.map_type_bound(&block)) },
-          accessibility: @accessibility,
-          alias_of: alias_of
+          defs: defs.map {|defn| defn.update(type: defn.type.map_type_bound(&block)) }
         )
       end
 
       def map_method_type(&block)
-        self.class.new(
-          super_method: super_method,
+        update(
           defs: defs.map {|defn| defn.update(type: yield(defn.type)) },
-          accessibility: @accessibility,
-          alias_of: alias_of
         )
       end
 
-      def update(super_method: self.super_method, defs: self.defs, accessibility: self.accessibility, alias_of: self.alias_of, annotations: self.annotations)
+      def update(super_method: self.super_method, defs: self.defs, accessibility: self.accessibility, alias_of: self.alias_of, annotations: self.annotations, alias_member: self.alias_member)
         self.class.new(
           super_method: super_method,
           defs: defs,
           accessibility: accessibility,
           alias_of: alias_of,
-          annotations: annotations
-        )
+          alias_member: alias_member
+        ).tap do |method|
+          method.annotations.replace(annotations)
+        end
       end
     end
 
@@ -347,6 +360,8 @@ module RBS
     end
 
     def sub(s)
+      return self if s.empty?
+
       definition = self.class.new(type_name: type_name, self_type: _ = self_type.sub(s), ancestors: ancestors, entry: entry)
 
       definition.methods.merge!(methods.transform_values {|method| method.sub(s) })

data/lib/rbs/definition_builder/ancestor_builder.rb

@@ -217,6 +217,7 @@ module RBS
             NoSuperclassFoundError.check!(super_name, env: env, location: primary.decl.location)
             if super_class
               InheritModuleError.check!(super_class, env: env)
+              InvalidTypeApplicationError.check2!(type_name: super_class.name, args: super_class.args, env: env, location: super_class.location)
             end
 
             super_entry = env.normalized_class_entry(super_name) or raise
@@ -243,6 +244,7 @@ module RBS
           else
             entry.self_types.each do |module_self|
               NoSelfTypeFoundError.check!(module_self, env: env)
+              InvalidTypeApplicationError.check2!(type_name: module_self.name, args: module_self.args, env: env, location: module_self.location)
 
               module_name = module_self.name
               if module_name.class?

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
@@ -386,12 +389,14 @@ module RBS
                       type: method_type,
                       member: initialize_def.member,
                       defined_in: initialize_def.defined_in,
-                      implemented_in: initialize_def.implemented_in,
-                      overload_annotations: initialize_def.overload_annotations
-                    )
+                      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
@@ -535,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(member: l.source)
+        end
+      when AST::Members::ClassInstanceVariable
+        if r.source.instance_of?(AST::Members::ClassInstanceVariable) && l.declared_in == r.declared_in
+          raise ClassInstanceVariableDuplicationError.new(member: l.source)
+        end
+      end
     end
 
     def import_methods(definition, module_name, module_methods, interfaces_methods, subst, self_type_methods)
@@ -626,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,9 +680,11 @@ module RBS
             type: subst.empty? ? overload.method_type : overload.method_type.sub(subst),
             member: original,
             defined_in: defined_in,
-            implemented_in: implemented_in,
-            overload_annotations: overload.annotations
-          )
+            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
@@ -664,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(
@@ -714,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
 
@@ -742,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|
@@ -752,12 +801,19 @@ module RBS
             type: subst.empty? ? overload.method_type : overload.method_type.sub(subst),
             member: overloading_def,
             defined_in: defined_in,
-            implemented_in: implemented_in,
-            overload_annotations: overload.annotations
+            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/errors.rb

@@ -322,6 +322,29 @@ module RBS
     end
   end
 
+  class VariableDuplicationError < DefinitionError
+    include DetailedMessageable
+
+    attr_reader :member
+
+    def initialize(member:)
+      @member = member
+
+      super "#{Location.to_string location}: Duplicated variable name #{member.name}"
+    end
+
+    def location
+      loc = @member.location or raise
+      loc[:name]
+    end
+  end
+
+  class InstanceVariableDuplicationError < VariableDuplicationError
+  end
+
+  class ClassInstanceVariableDuplicationError < VariableDuplicationError
+  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/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)

data/lib/rbs/subtractor.rb

@@ -40,7 +40,7 @@ module RBS
           name = absolute_typename(decl.new_name, context: context)
           decl unless @subtrahend.module_alias?(name) || @subtrahend.module_decl?(name)
         else
-          raise "unknwon decl: #{(_ = decl).class}"
+          raise "unknown decl: #{(_ = decl).class}"
         end
       end.compact
     end
@@ -51,7 +51,7 @@ module RBS
       context = _ = [context, decl.name]
       children = call(decl.each_decl.to_a, context: context) +
         decl.each_member.reject { |m| member_exist?(owner, m, context: context) }
-      children = filter_redundunt_access_modifiers(children)
+      children = filter_redundant_access_modifiers(children)
       return nil if children.empty?
 
       update_decl(decl, members: children)
@@ -145,7 +145,7 @@ module RBS
       end
     end
 
-    private def filter_redundunt_access_modifiers(decls)
+    private def filter_redundant_access_modifiers(decls)
       decls = decls.dup
       decls.pop while access_modifier?(decls.last)
       decls = decls.map.with_index do |decl, i|

data/lib/rbs/test/hook.rb

@@ -27,8 +27,8 @@ module RBS
         :! => "not",
         :<< => "lshift",
         :>> => "rshift",
-        :~ => "tilda",
-        :=~ => "eqtilda",
+        :~ => "tilde",
+        :=~ => "eqtilde",
         :% => "percent",
         :+@ => "unary_plus",
         :-@ => "unary_minus"