rbs 4.0.0.dev.4 → 4.0.0.dev.5

data/lib/rbs/definition_builder/method_builder.rb

@@ -149,6 +149,8 @@ module RBS
                         member: member,
                         accessibility: :public
                       )
+                    when AST::Ruby::Members::AttrReaderMember, AST::Ruby::Members::AttrWriterMember, AST::Ruby::Members::AttrAccessorMember
+                      build_ruby_attribute(methods, type, member: member, accessibility: :public)
                     end
                   end
                 end
@@ -227,6 +229,24 @@ module RBS
         end
       end
 
+      def build_ruby_attribute(methods, type, member:, accessibility:)
+        member.names.each do |name|
+          if member.is_a?(AST::Ruby::Members::AttrReaderMember) || member.is_a?(AST::Ruby::Members::AttrAccessorMember)
+            defn = methods.methods[name] ||= Methods::Definition.empty(type: type, name: name)
+
+            defn.accessibilities << accessibility
+            defn.originals << member
+          end
+
+          if member.is_a?(AST::Ruby::Members::AttrWriterMember) || member.is_a?(AST::Ruby::Members::AttrAccessorMember)
+            defn = methods.methods[:"#{name}="] ||= Methods::Definition.empty(type: type, name: :"#{name}=")
+
+            defn.accessibilities << accessibility
+            defn.originals << member
+          end
+        end
+      end
+
       def build_method(methods, type, member:, accessibility:)
         defn = methods.methods[member.name] ||= Methods::Definition.empty(type: type, name: member.name)
 

data/lib/rbs/definition_builder.rb

@@ -151,6 +151,29 @@ module RBS
               end
             end
 
+          when AST::Ruby::Members::AttrReaderMember, AST::Ruby::Members::AttrWriterMember, AST::Ruby::Members::AttrAccessorMember
+            member.names.each do |name|
+              ivar_name = :"@#{name}"
+              attr_type = member.type || Types::Bases::Any.new(location: nil)
+
+              insert_variable(
+                type_name,
+                definition.instance_variables,
+                name: ivar_name,
+                type: attr_type,
+                source: member
+              )
+            end
+
+          when AST::Ruby::Members::InstanceVariableMember
+            insert_variable(
+              type_name,
+              definition.instance_variables,
+              name: member.name,
+              type: member.type,
+              source: member
+            )
+
           when AST::Members::InstanceVariable
             insert_variable(
               type_name,
@@ -551,6 +574,7 @@ module RBS
         declared_in: type_name,
         source: source
       )
+
       validate_variable(variables[name])
     end
 
@@ -561,7 +585,15 @@ module RBS
       variables = [] #: Array[Definition::Variable]
       tmp_var = var
       while tmp_var
-        variables << tmp_var if tmp_var.source.is_a?(AST::Members::Var)
+        case tmp_var.source
+        when AST::Members::AttrReader, AST::Members::AttrWriter, AST::Members::AttrAccessor
+          # nop
+        when AST::Ruby::Members::AttrReaderMember, AST::Ruby::Members::AttrWriterMember, AST::Ruby::Members::AttrAccessorMember
+          # nop
+        else
+          variables << tmp_var
+        end
+
         tmp_var = tmp_var.parent_variable
       end
 
@@ -579,6 +611,10 @@ module RBS
         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
+      when AST::Ruby::Members::InstanceVariableMember
+        if l.declared_in == r.declared_in
+          raise InstanceVariableDuplicationError.new(type_name: l.declared_in, variable_name: l.source.name, location: l.source.location)
+        end
       end
     end
 
@@ -606,7 +642,7 @@ module RBS
 
         methods.each do |method|
           if interface_method_duplicates.include?(method.name)
-            member.is_a?(AST::Members::Include) || member.is_a?(AST::Members::Extend) or raise
+            (member.is_a?(AST::Members::Include) || member.is_a?(AST::Members::Extend)) or raise
 
             raise DuplicatedInterfaceMethodDefinitionError.new(
               type: definition.self_type,
@@ -766,6 +802,59 @@ module RBS
         )
 
         method_definition.annotations.replace(original.annotations)
+      when AST::Ruby::Members::AttrReaderMember, AST::Ruby::Members::AttrWriterMember, AST::Ruby::Members::AttrAccessorMember
+        if duplicated_method = methods[method.name]
+          raise DuplicatedMethodDefinitionError.new(
+            type: definition.self_type,
+            method_name: method.name,
+            members: [*duplicated_method.members, original]
+          )
+        end
+
+        attr_type = original.type || Types::Bases::Any.new(location: nil)
+        method_type =
+          if method.name.to_s.end_with?("=")
+            # setter
+            MethodType.new(
+              type_params: [],
+              type: Types::Function.empty(attr_type).update(
+                required_positionals: [
+                  Types::Function::Param.new(type: attr_type, name: method.name.to_s.chomp("=").to_sym)
+                ]
+              ),
+              block: nil,
+              location: original.location
+            )
+          else
+            # getter
+            MethodType.new(
+              type_params: [],
+              type: Types::Function.empty(attr_type),
+              block: nil,
+              location: original.location
+            )
+          end
+
+        if implemented_in
+          super_method = existing_method
+        end
+
+        method_definition = Definition::Method.new(
+          super_method: super_method,
+          defs: [
+            Definition::Method::TypeDef.new(
+              type: method_type,
+              member: original,
+              defined_in: defined_in,
+              implemented_in: implemented_in
+            )
+          ],
+          accessibility: method.accessibility,
+          alias_of: nil,
+          alias_member: nil
+        )
+
+        method_definition.annotations.replace([])
       when AST::Ruby::Members::DefMember
         if duplicated_method = methods[method.name]
           raise DuplicatedMethodDefinitionError.new(

data/lib/rbs/diff.rb

@@ -104,7 +104,13 @@ module RBS
         detail_to_s = @detail ? "[#{definition_method.defined_in} #{definition_method.accessibility}] " : ""
         if definition_method.alias_of
           first_def = definition_method.alias_of.defs.first #: Definition::Method::TypeDef
-          "#{detail_to_s}alias #{prefix}#{key} #{prefix}#{first_def.member.name}"
+          member_name = case first_def.member
+                        when AST::Members::Base
+                          first_def.member.name
+                        else
+                          raise
+                        end
+          "#{detail_to_s}alias #{prefix}#{key} #{prefix}#{member_name}"
         else
           "#{detail_to_s}def #{prefix}#{key}: #{definition_method.method_types.join(" | ")}"
         end

data/lib/rbs/environment.rb

@@ -122,21 +122,17 @@ module RBS
       end
     end
 
-    def class_entry(type_name)
-      case
-      when (class_entry = class_decls[type_name]).is_a?(ClassEntry)
-        class_entry
-      when (class_alias = class_alias_decls[type_name]).is_a?(ClassAliasEntry)
-        class_alias
+    def class_entry(type_name, normalized: false)
+      case entry = constant_entry(type_name, normalized: normalized || false)
+      when ClassEntry, ClassAliasEntry
+        entry
       end
     end
 
-    def module_entry(type_name)
-      case
-      when (module_entry = class_decls[type_name]).is_a?(ModuleEntry)
-        module_entry
-      when (module_alias = class_alias_decls[type_name]).is_a?(ModuleAliasEntry)
-        module_alias
+    def module_entry(type_name, normalized: false)
+      case entry = constant_entry(type_name, normalized: normalized || false)
+      when ModuleEntry, ModuleAliasEntry
+        entry
       end
     end
 
@@ -152,26 +148,40 @@ module RBS
     end
 
     def normalized_module_entry(type_name)
-      if name = normalize_module_name?(type_name)
-        case entry = module_entry(name)
-        when ModuleEntry, nil
-          entry
-        when ModuleAliasEntry
-          raise
-        end
-      end
+      module_entry(type_name, normalized: true)
     end
 
-    def module_class_entry(type_name)
-      class_entry(type_name) || module_entry(type_name)
+    def module_class_entry(type_name, normalized: false)
+      entry = constant_entry(type_name, normalized: normalized || false)
+      if entry.is_a?(ConstantEntry)
+        nil
+      else
+        entry
+      end
     end
 
     def normalized_module_class_entry(type_name)
-      normalized_class_entry(type_name) || normalized_module_entry(type_name)
+      module_class_entry(type_name, normalized: true)
     end
 
-    def constant_entry(type_name)
-      class_entry(type_name) || module_entry(type_name) || constant_decls[type_name]
+    def constant_entry(type_name, normalized: false)
+      if normalized
+        if normalized_name = normalize_module_name?(type_name)
+          class_decls.fetch(normalized_name, nil)
+        else
+          # The type_name may be declared with constant declaration
+          unless type_name.namespace.empty?
+            parent = type_name.namespace.to_type_name
+            normalized_parent = normalize_module_name?(parent) or return
+            constant_name = TypeName.new(name: type_name.name, namespace: normalized_parent.to_namespace)
+            constant_decls.fetch(constant_name, nil)
+          end
+        end
+      else
+        class_decls.fetch(type_name, nil) ||
+          class_alias_decls.fetch(type_name, nil) ||
+          constant_decls.fetch(type_name, nil)
+      end
     end
 
     def normalize_type_name?(name)
@@ -206,6 +216,10 @@ module RBS
       end
     end
 
+    def normalize_type_name(name)
+      normalize_type_name?(name) || name
+    end
+
     def normalized_type_name?(type_name)
       case
       when type_name.interface?
@@ -220,53 +234,44 @@ module RBS
     end
 
     def normalized_type_name!(name)
-      normalized_type_name?(name) or raise "Normalized type name is expected but given `#{name}`, which is normalized to `#{normalize_type_name?(name)}`"
+      normalized_type_name?(name) or raise "Normalized type name is expected but given `#{name}`"
       name
     end
 
-    def normalize_type_name(name)
-      normalize_type_name?(name) || name
-    end
-
-    def normalize_module_name(name)
-      normalize_module_name?(name) or name
-    end
-
     def normalize_module_name?(name)
       raise "Class/module name is expected: #{name}" unless name.class?
       name = name.absolute! unless name.absolute?
 
-      if @normalize_module_name_cache.key?(name)
-        return @normalize_module_name_cache[name]
+      original_name = name
+
+      if @normalize_module_name_cache.key?(original_name)
+        return @normalize_module_name_cache[original_name]
       end
 
-      unless name.namespace.empty?
-        parent = name.namespace.to_type_name
-        if normalized_parent = normalize_module_name?(parent)
-          type_name = TypeName.new(namespace: normalized_parent.to_namespace, name: name.name)
-        else
-          @normalize_module_name_cache[name] = nil
-          return
+      if alias_entry = class_alias_decls.fetch(name, nil)
+        unless alias_entry.decl.old_name.absolute?
+          # Having relative old_name means the type name resolution was failed.
+          # Run TypeNameResolver for failure reason
+          resolver = Resolver::TypeNameResolver.build(self)
+          name = resolver.resolve_namespace(name, context: nil)
+          @normalize_module_name_cache[original_name] = name
+          return name
         end
-      else
-        type_name = name
-      end
 
-      @normalize_module_name_cache[name] = false
+        name = alias_entry.decl.old_name
+      end
 
-      entry = constant_entry(type_name)
+      if class_decls.key?(name)
+        @normalize_module_name_cache[original_name] = name
+      end
+    end
 
-      normalized_type_name =
-        case entry
-        when ClassEntry, ModuleEntry
-          type_name
-        when ClassAliasEntry, ModuleAliasEntry
-          normalize_module_name?(entry.decl.old_name)
-        else
-          nil
-        end
+    def normalize_module_name(name)
+      normalize_module_name?(name) || name
+    end
 
-      @normalize_module_name_cache[name] = normalized_type_name
+    def normalize_module_name!(name)
+      normalize_module_name?(name) or raise "Module name `#{name}` cannot be normalized"
     end
 
     def insert_rbs_decl(decl, context:, namespace:)
@@ -378,11 +383,10 @@ module RBS
           if entry.is_a?(ModuleEntry)
             raise DuplicatedDeclarationError.new(name, decl, *entry.each_decl.to_a)
           end
+        else
+          entry = class_decls[name] = ClassEntry.new(name)
         end
 
-        entry = ClassEntry.new(name)
-        class_decls[name] = entry
-
         entry << [context, decl]
 
         inner_context = [context, name] #: Resolver::context
@@ -400,17 +404,51 @@ module RBS
           if entry.is_a?(ClassEntry)
             raise DuplicatedDeclarationError.new(name, decl, *entry.each_decl.to_a)
           end
+        else
+          entry = class_decls[name] = ModuleEntry.new(name)
         end
 
-        entry = ModuleEntry.new(name)
-        class_decls[name] = entry
-
         entry << [context, decl]
 
         inner_context = [context, name] #: Resolver::context
         decl.each_decl do |member|
           insert_ruby_decl(member, context: inner_context, namespace: name.to_namespace)
         end
+
+      when AST::Ruby::Declarations::ConstantDecl
+        name = decl.constant_name.with_prefix(namespace)
+
+        if entry = constant_entry(name)
+          case entry
+          when ClassAliasEntry, ModuleAliasEntry, ConstantEntry
+            raise DuplicatedDeclarationError.new(name, decl, entry.decl)
+          when ClassEntry, ModuleEntry
+            raise DuplicatedDeclarationError.new(name, decl, *entry.each_decl.to_a)
+          end
+        end
+
+        constant_decls[name] = ConstantEntry.new(name: name, decl: decl, context: context)
+
+      when AST::Ruby::Declarations::ClassModuleAliasDecl
+        name = decl.new_name.with_prefix(namespace)
+
+        if entry = constant_entry(name)
+          case entry
+          when ClassAliasEntry, ModuleAliasEntry, ConstantEntry
+            raise DuplicatedDeclarationError.new(name, decl, entry.decl)
+          when ClassEntry, ModuleEntry
+            raise DuplicatedDeclarationError.new(name, decl, *entry.each_decl.to_a)
+          end
+        end
+
+        case decl.annotation
+        when AST::Ruby::Annotations::ClassAliasAnnotation
+          class_alias_decls[name] = ClassAliasEntry.new(name: name, decl: decl, context: context)
+        when AST::Ruby::Annotations::ModuleAliasAnnotation
+          class_alias_decls[name] = ModuleAliasEntry.new(name: name, decl: decl, context: context)
+        end
+      else
+        raise "Unknown Ruby declaration type: #{decl.class}"
       end
     end
 
@@ -482,7 +520,7 @@ module RBS
     end
 
     def resolve_type_names(only: nil)
-      resolver = Resolver::TypeNameResolver.new(self)
+      resolver = Resolver::TypeNameResolver.build(self)
       env = Environment.new
 
       table = UseMap::Table.new()
@@ -495,7 +533,7 @@ module RBS
       each_rbs_source do |source|
         resolve = source.directives.find { _1.is_a?(AST::Directives::ResolveTypeNames) } #: AST::Directives::ResolveTypeNames?
         if !resolve || resolve.value
-          _, decls = resolve_signature(resolver, table, source.directives, source.declarations)
+          _, decls = resolve_signature(resolver, table, source.directives, source.declarations, only: only)
         else
           decls = source.declarations
         end
@@ -504,7 +542,15 @@ module RBS
 
       each_ruby_source do |source|
         decls = source.declarations.map do |decl|
-          resolve_ruby_decl(resolver, decl, context: nil, prefix: Namespace.root)
+          if only
+            if only.include?(decl)
+              resolve_ruby_decl(resolver, decl, context: nil, prefix: Namespace.root)
+            else
+              decl
+            end
+          else
+            resolve_ruby_decl(resolver, decl, context: nil, prefix: Namespace.root)
+          end
         end
 
         env.add_source(Source::Ruby.new(source.buffer, source.prism_result, decls, source.diagnostics))
@@ -671,7 +717,16 @@ module RBS
         inner_context = [context, full_name] #: Resolver::context
         inner_prefix = full_name.to_namespace
 
-        AST::Ruby::Declarations::ClassDecl.new(decl.buffer, full_name, decl.node).tap do |resolved|
+        super_class = decl.super_class&.yield_self do |super_class|
+          AST::Ruby::Declarations::ClassDecl::SuperClass.new(
+            super_class.type_name_location,
+            super_class.operator_location,
+            absolute_type_name(resolver, nil, super_class.name, context: context),
+            super_class.type_annotation&.map_type_name {|name, _, _| absolute_type_name(resolver, nil, name, context: context) }
+          )
+        end
+
+        AST::Ruby::Declarations::ClassDecl.new(decl.buffer, full_name, decl.node, super_class).tap do |resolved|
           decl.members.each do |member|
             case member
             when AST::Ruby::Declarations::Base
@@ -694,12 +749,39 @@ module RBS
             case member
             when AST::Ruby::Declarations::Base
               resolved.members << resolve_ruby_decl(resolver, member, context: inner_context, prefix: inner_prefix)
+            when AST::Ruby::Members::Base
+              resolved.members << resolve_ruby_member(resolver, member, context: inner_context)
             else
               raise "Unknown member type: #{member.class}"
             end
           end
         end
 
+      when AST::Ruby::Declarations::ConstantDecl
+        full_name = decl.constant_name.with_prefix(prefix)
+
+        AST::Ruby::Declarations::ConstantDecl.new(
+          decl.buffer,
+          full_name,
+          decl.node,
+          decl.leading_comment,
+          decl.type_annotation&.map_type_name {|name, _, _| absolute_type_name(resolver, nil, name, context: context) }
+        )
+
+      when AST::Ruby::Declarations::ClassModuleAliasDecl
+        full_name = decl.new_name.with_prefix(prefix)
+        resolved_annotation = decl.annotation.map_type_name {|name, _, _| absolute_type_name(resolver, nil, name, context: context) }
+        resolved_infered_name = decl.infered_old_name&.yield_self {|name| absolute_type_name(resolver, nil, name, context: context) }
+
+        AST::Ruby::Declarations::ClassModuleAliasDecl.new(
+          decl.buffer,
+          decl.node,
+          full_name,
+          resolved_infered_name,
+          decl.leading_comment,
+          resolved_annotation
+        )
+
       else
         raise "Unknown declaration type: #{decl.class}"
       end
@@ -712,7 +794,65 @@ module RBS
           member.buffer,
           member.name,
           member.node,
-          member.method_type.map_type_name {|name, _, _| absolute_type_name(resolver, nil, name, context: context) }
+          member.method_type.map_type_name {|name, _, _| absolute_type_name(resolver, nil, name, context: context) },
+          member.leading_comment
+        )
+      when AST::Ruby::Members::IncludeMember
+        resolved_annotation = member.annotation&.map_type_name {|name, _, _| absolute_type_name(resolver, nil, name, context: context) }
+        AST::Ruby::Members::IncludeMember.new(
+          member.buffer,
+          member.node,
+          absolute_type_name(resolver, nil, member.module_name, context: context),
+          resolved_annotation
+        )
+      when AST::Ruby::Members::ExtendMember
+        resolved_annotation = member.annotation&.map_type_name {|name, _, _| absolute_type_name(resolver, nil, name, context: context) }
+        AST::Ruby::Members::ExtendMember.new(
+          member.buffer,
+          member.node,
+          absolute_type_name(resolver, nil, member.module_name, context: context),
+          resolved_annotation
+        )
+      when AST::Ruby::Members::PrependMember
+        resolved_annotation = member.annotation&.map_type_name {|name, _, _| absolute_type_name(resolver, nil, name, context: context) }
+        AST::Ruby::Members::PrependMember.new(
+          member.buffer,
+          member.node,
+          absolute_type_name(resolver, nil, member.module_name, context: context),
+          resolved_annotation
+        )
+      when AST::Ruby::Members::AttrReaderMember
+        resolved_type_annotation = member.type_annotation&.map_type_name {|name, _, _| absolute_type_name(resolver, nil, name, context: context) }
+        AST::Ruby::Members::AttrReaderMember.new(
+          member.buffer,
+          member.node,
+          member.name_nodes,
+          member.leading_comment,
+          resolved_type_annotation
+        )
+      when AST::Ruby::Members::AttrWriterMember
+        resolved_type_annotation = member.type_annotation&.map_type_name {|name, _, _| absolute_type_name(resolver, nil, name, context: context) }
+        AST::Ruby::Members::AttrWriterMember.new(
+          member.buffer,
+          member.node,
+          member.name_nodes,
+          member.leading_comment,
+          resolved_type_annotation
+        )
+      when AST::Ruby::Members::AttrAccessorMember
+        resolved_type_annotation = member.type_annotation&.map_type_name {|name, _, _| absolute_type_name(resolver, nil, name, context: context) }
+        AST::Ruby::Members::AttrAccessorMember.new(
+          member.buffer,
+          member.node,
+          member.name_nodes,
+          member.leading_comment,
+          resolved_type_annotation
+        )
+      when AST::Ruby::Members::InstanceVariableMember
+        resolved_annotation = member.annotation.map_type_name {|name| absolute_type_name(resolver, nil, name, context: context) }
+        AST::Ruby::Members::InstanceVariableMember.new(
+          member.buffer,
+          resolved_annotation
         )
       else
         raise "Unknown member type: #{member.class}"
@@ -845,7 +985,7 @@ module RBS
     end
 
     def inspect
-      ivars = %i[@declarations @class_decls @class_alias_decls @interface_decls @type_alias_decls @constant_decls @global_decls]
+      ivars = %i[@sources @class_decls @class_alias_decls @interface_decls @type_alias_decls @constant_decls @global_decls]
       "\#<RBS::Environment #{ivars.map { |iv| "#{iv}=(#{instance_variable_get(iv).size} items)"}.join(' ')}>"
     end
 
@@ -853,12 +993,25 @@ module RBS
       sources.map(&:buffer)
     end
 
-    def unload(buffers)
-      env = Environment.new
-      bufs = buffers.to_set
+    def unload(paths)
+      ps = Set[]
+      paths.each do |path|
+        if path.is_a?(Buffer)
+          ps << path.name
+        else
+          ps << path
+        end
+      end
+
+      env = Environment.new()
 
       each_rbs_source do |source|
-        next if bufs.include?(source.buffer)
+        next if ps.include?(source.buffer.name)
+        env.add_source(source)
+      end
+
+      each_ruby_source do |source|
+        next if ps.include?(source.buffer.name)
         env.add_source(source)
       end
 

data/lib/rbs/environment_loader.rb

@@ -50,12 +50,6 @@ module RBS
       when path
         dirs << path
       when library
-        case library
-        when 'rubygems', 'set'
-          RBS.logger.warn "`#{library}` has been moved to core library, so it is always loaded. Remove explicit loading `#{library}`"
-          return
-        end
-
         if libs.add?(Library.new(name: library, version: version)) && resolve_dependencies
           resolve_dependencies(library: library, version: version)
         end