rbs 4.0.0.dev.4 → 4.0.0

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

data/lib/rbs/errors.rb

@@ -93,7 +93,7 @@ module RBS
       params =
         case
         when type_name.class?
-          decl = env.normalized_module_class_entry(type_name) or raise
+          decl = env.module_class_entry(type_name, normalized: true) or raise
           decl.type_params
         when type_name.interface?
           env.interface_decls.fetch(type_name).decl.type_params
@@ -475,7 +475,7 @@ module RBS
       @type_name = type_name
       @member = member
 
-      super "#{Location.to_string member.location}: Cannot #{mixin_name} a class `#{member.name}` in the definition of `#{type_name}`"
+      super "#{Location.to_string member.location}: Cannot #{mixin_name} a class `#{member_name(member)}` in the definition of `#{type_name}`"
     end
 
     def location
@@ -483,23 +483,43 @@ module RBS
     end
 
     def self.check!(type_name:, env:, member:)
-      if env.class_decl?(member.name)
+      name = case member
+             when AST::Members::Include, AST::Members::Extend, AST::Members::Prepend
+               member.name
+             when AST::Ruby::Members::IncludeMember, AST::Ruby::Members::ExtendMember, AST::Ruby::Members::PrependMember
+               member.module_name
+             else
+               raise "Unknown member type: #{member.class}"
+             end
+
+      if env.class_decl?(name)
         raise new(type_name: type_name, member: member)
       end
     end
 
     private
 
+    def member_name(member)
+      case member
+      when AST::Members::Include, AST::Members::Extend, AST::Members::Prepend
+        member.name
+      when AST::Ruby::Members::IncludeMember, AST::Ruby::Members::ExtendMember, AST::Ruby::Members::PrependMember
+        member.module_name
+      else
+        raise "Unknown member type: #{member.class}"
+      end
+    end
+
     def mixin_name
       case member
-      when AST::Members::Prepend
+      when AST::Members::Prepend, AST::Ruby::Members::PrependMember
         "prepend"
-      when AST::Members::Include
+      when AST::Members::Include, AST::Ruby::Members::IncludeMember
         "include"
-      when AST::Members::Extend
+      when AST::Members::Extend, AST::Ruby::Members::ExtendMember
         "extend"
       else
-        raise
+        raise "Unknown member type: #{member.class}"
       end
     end
   end
@@ -591,17 +611,6 @@ module RBS
     end
   end
 
-  class WillSyntaxError < DefinitionError
-    include DetailedMessageable
-
-    attr_reader :location
-
-    def initialize(message, location:)
-      super "#{Location.to_string(location)}: #{message}"
-      @location = location
-    end
-  end
-
   class TypeParamDefaultReferenceError < DefinitionError
     include DetailedMessageable