rbs 0.14.0 → 0.18.1

data/lib/rbs/definition.rb

@@ -60,12 +60,14 @@ module RBS
       attr_reader :defs
       attr_reader :accessibility
       attr_reader :extra_annotations
+      attr_reader :alias_of
 
-      def initialize(super_method:, defs:, accessibility:, annotations: [])
+      def initialize(super_method:, defs:, accessibility:, annotations: [], alias_of:)
         @super_method = super_method
         @defs = defs
         @accessibility = accessibility
         @extra_annotations = annotations
+        @alias_of = alias_of
       end
 
       def defined_in
@@ -110,7 +112,8 @@ module RBS
         self.class.new(
           super_method: super_method&.sub(s),
           defs: defs.map {|defn| defn.update(type: defn.type.sub(s)) },
-          accessibility: @accessibility
+          accessibility: @accessibility,
+          alias_of: alias_of
         )
       end
 
@@ -118,7 +121,8 @@ module RBS
         self.class.new(
           super_method: super_method&.map_type(&block),
           defs: defs.map {|defn| defn.update(type: defn.type.map_type(&block)) },
-          accessibility: @accessibility
+          accessibility: @accessibility,
+          alias_of: alias_of
         )
       end
 
@@ -126,7 +130,8 @@ module RBS
         self.class.new(
           super_method: super_method,
           defs: defs.map {|defn| defn.update(type: yield(defn.type)) },
-          accessibility: @accessibility
+          accessibility: @accessibility,
+          alias_of: alias_of
         )
       end
     end

data/lib/rbs/definition_builder.rb

@@ -599,10 +599,15 @@ module RBS
       try_cache(type_name, cache: one_instance_cache) do
         entry = env.class_decls[type_name]
 
+        param_names = entry.type_params.each.map(&:name)
         self_type = Types::ClassInstance.new(name: type_name,
-                                             args: Types::Variable.build(entry.type_params.each.map(&:name)),
+                                             args: Types::Variable.build(param_names),
                                              location: nil)
-        ancestors = [Definition::Ancestor::Instance.new(name: type_name, args: self_type.args)]
+        ancestors = Definition::InstanceAncestors.new(
+          type_name: type_name,
+          params: param_names,
+          ancestors: [Definition::Ancestor::Instance.new(name: type_name, args: self_type.args)]
+        )
 
         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|
@@ -618,13 +623,15 @@ module RBS
                   Definition::Method.new(
                     super_method: nil,
                     accessibility: visibility,
-                    defs: method_def.defs.map {|defn| defn.update(implemented_in: type_name) }
+                    defs: method_def.defs.map {|defn| defn.update(implemented_in: type_name) },
+                    alias_of: nil
                   )
                 else
                   Definition::Method.new(
                     super_method: nil,
                     accessibility: visibility,
-                    defs: []
+                    defs: [],
+                    alias_of: nil
                   )
                 end
 
@@ -641,7 +648,8 @@ module RBS
               Definition::Method.new(
                 super_method: nil,
                 defs: defs + original.defs,
-                accessibility: original.accessibility
+                accessibility: original.accessibility,
+                alias_of: nil
               )
             end
           end
@@ -676,7 +684,8 @@ module RBS
                         implemented_in: type_name
                       )
                     ],
-                    accessibility: accessibility
+                    accessibility: accessibility,
+                    alias_of: nil
                   )
                 end
 
@@ -698,7 +707,8 @@ module RBS
                         implemented_in: type_name
                       ),
                     ],
-                    accessibility: accessibility
+                    accessibility: accessibility,
+                    alias_of: nil
                   )
                 end
 
@@ -747,7 +757,15 @@ module RBS
                     location: member.location
                   )
 
-                  definition.methods[member.new_name] = definition.methods[member.old_name]
+                  original_method = definition.methods[member.old_name]
+
+                  definition.methods[member.new_name] = Definition::Method.new(
+                    super_method: original_method.super_method,
+                    defs: original_method.defs,
+                    accessibility: original_method.accessibility,
+                    alias_of: original_method,
+                    annotations: original_method.annotations
+                  )
                 end
               end
             end
@@ -838,7 +856,10 @@ module RBS
         entry = env.class_decls[type_name]
 
         self_type = Types::ClassSingleton.new(name: type_name, location: nil)
-        ancestors = [Definition::Ancestor::Singleton.new(name: type_name)]
+        ancestors = Definition::SingletonAncestors.new(
+          type_name: type_name,
+          ancestors: [Definition::Ancestor::Singleton.new(name: type_name)]
+        )
 
         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|
@@ -855,7 +876,8 @@ module RBS
               defs: method_def&.yield_self do |method_def|
                 method_def.defs.map {|defn| defn.update(implemented_in: type_name) }
               end || [],
-              accessibility: visibility
+              accessibility: visibility,
+              alias_of: nil
             )
             definition.methods[method_name] = members.inject(m) do |original, new|
               defs = new.types.map do |type|
@@ -869,7 +891,8 @@ module RBS
               Definition::Method.new(
                 super_method: nil,
                 defs: defs + original.defs,
-                accessibility: original.accessibility
+                accessibility: original.accessibility,
+                alias_of: nil
               )
             end
           end
@@ -893,7 +916,14 @@ module RBS
                     location: member.location
                   )
 
-                  definition.methods[member.new_name] = definition.methods[member.old_name]
+                  original_method = definition.methods[member.old_name]
+                  definition.methods[member.new_name] = Definition::Method.new(
+                    super_method: original_method.super_method,
+                    defs: original_method.defs,
+                    accessibility: original_method.accessibility,
+                    alias_of: original_method,
+                    annotations: original_method.annotations
+                  )
                 end
               end
             end
@@ -940,12 +970,13 @@ module RBS
                   Definition::Method::TypeDef.new(
                     type: method_type,
                     member: initialize_def.member,
-                    defined_in: nil,
-                    implemented_in: nil
+                    defined_in: initialize_def.defined_in,
+                    implemented_in: initialize_def.implemented_in
                   )
                 end,
                 accessibility: :public,
-                annotations: [AST::Annotation.new(location: nil, string: "rbs:test:target")]
+                annotations: [AST::Annotation.new(location: nil, string: "rbs:test:target")],
+                alias_of: nil
               )
             end
           end
@@ -1029,7 +1060,8 @@ module RBS
       methods[name] = Definition::Method.new(
         super_method: super_method,
         accessibility: method.accessibility,
-        defs: sub.mapping.empty? ? defs : 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)) },
+        alias_of: nil
       )
     end
 
@@ -1123,7 +1155,8 @@ module RBS
                   implemented_in: nil
                 )
               end,
-              accessibility: :public
+              accessibility: :public,
+              alias_of: nil
             )
             definition.methods[member.name] = method
           end

data/lib/rbs/environment_loader.rb

@@ -1,156 +1,130 @@
 module RBS
   class EnvironmentLoader
-    class UnknownLibraryNameError < StandardError
-      attr_reader :name
+    class UnknownLibraryError < StandardError
+      attr_reader :library
 
-      def initialize(name:)
-        @name = name
-        super "Cannot find a library or gem: `#{name}`"
+      def initialize(lib:)
+        @library = lib
+
+        super("Cannot find type definitions for library: #{lib.name} (#{lib.version || "[nil]"})")
       end
     end
 
-    LibraryPath = _ = Struct.new(:name, :path, keyword_init: true)
-    GemPath = _ = Struct.new(:name, :version, :path, keyword_init: true)
+    Library = _ = Struct.new(:name, :version, keyword_init: true)
+
+    attr_reader :core_root
+    attr_reader :repository
 
-    attr_reader :paths
-    attr_reader :stdlib_root
-    attr_reader :gem_vendor_path
+    attr_reader :libs
+    attr_reader :dirs
 
-    STDLIB_ROOT = Pathname(_ = __dir__) + "../../stdlib"
+    DEFAULT_CORE_ROOT = Pathname(_ = __dir__) + "../../core"
 
     def self.gem_sig_path(name, version)
-      Pathname(Gem::Specification.find_by_name(name, version).gem_dir) + "sig"
+      spec = Gem::Specification.find_by_name(name, version)
+      path = Pathname(spec.gem_dir) + "sig"
+      if path.directory?
+        [spec, path]
+      end
     rescue Gem::MissingSpecError
       nil
     end
 
-    def initialize(stdlib_root: STDLIB_ROOT, gem_vendor_path: nil)
-      @stdlib_root = stdlib_root
-      @gem_vendor_path = gem_vendor_path
-      @paths = []
-      @no_builtin = false
+    def initialize(core_root: DEFAULT_CORE_ROOT, repository: Repository.new)
+      @core_root = core_root
+      @repository = repository
+
+      @libs = []
+      @dirs = []
     end
 
-    def add(path: nil, library: nil)
+    def add(path: nil, library: nil, version: nil)
       case
       when path
-        @paths << path
+        dirs << path
       when library
-        name, version = self.class.parse_library(library)
-
-        case
-        when !version && path = stdlib?(name)
-          @paths << LibraryPath.new(name: name, path: path)
-        when (path = gem?(name, version))
-          @paths << GemPath.new(name: name, version: version, path: path)
-        else
-          raise UnknownLibraryNameError.new(name: library)
-        end
+        libs << Library.new(name: library, version: version)
       end
     end
 
-    def self.parse_library(lib)
-      _ = lib.split(/:/)
+    def has_library?(library:, version:)
+      self.class.gem_sig_path(library, version) || repository.lookup(library, version)
     end
 
-    def stdlib?(name)
-      path = stdlib_root + name
-      if path.directory?
-        path
+    def load(env:)
+      # @type var loaded: Array[[AST::Declarations::t, Pathname, source]]
+      loaded = []
+
+      each_decl do |decl, buf, source, path|
+        env << decl
+        loaded << [decl, path, source]
       end
+
+      loaded
     end
 
-    def gem?(name, version)
-      if path = gem_vendor_path
-        # Try vendored RBS first
-        gem_dir = path + name
-        if gem_dir.directory?
-          return gem_dir
-        end
+    def each_dir
+      if root = core_root
+        yield :core, root
       end
 
-      # Try ruby gem library
-      self.class.gem_sig_path(name, version)
-    end
+      libs.each do |lib|
+        unless has_library?(version: lib.version, library: lib.name)
+          raise UnknownLibraryError.new(lib: lib) 
+        end
 
-    def each_signature(path, immediate: true, &block)
-      if block
         case
-        when path.file?
-          if path.extname == ".rbs" || immediate
-            yield path
-          end
-        when path.directory?
-          path.children.each do |child|
-            each_signature child, immediate: false, &block
-          end
+        when from_gem = self.class.gem_sig_path(lib.name, lib.version)
+          yield lib, from_gem[1]
+        when from_repo = repository.lookup(lib.name, lib.version)
+          yield lib, from_repo
         end
-      else
-        enum_for :each_signature, path, immediate: immediate
       end
-    end
 
-    def each_library_path
-      paths.each do |path|
-        case path
-        when Pathname
-          yield path, path
-        when LibraryPath
-          yield path, path.path
-        when GemPath
-          yield path, path.path
-        end
+      dirs.each do |dir|
+        yield dir, dir
       end
     end
 
-    def no_builtin!(skip = true)
-      @no_builtin = skip
-      self
-    end
-
-    def no_builtin?
-      @no_builtin
-    end
-
-    def each_decl
-      if block_given?
-        # @type var signature_files: Array[[path | :stdlib, Pathname]]
-        signature_files = []
-
-        unless no_builtin?
-          each_signature(stdlib_root + "builtin") do |path|
-            signature_files << [:stdlib, path]
-          end
+    def each_file(path, immediate:, skip_hidden:, &block)
+      case
+      when path.file?
+        if path.extname == ".rbs" || immediate
+          yield path
         end
 
-        each_library_path do |library_path, pathname|
-          each_signature(pathname) do |path|
-            signature_files << [library_path, path]
+      when path.directory?
+        if path.basename.to_s.start_with?("_")
+          if skip_hidden
+            unless immediate
+              return 
+            end
           end
         end
 
-        signature_files.each do |lib_path, file_path|
-          buffer = Buffer.new(name: file_path.to_s, content: file_path.read)
-          Parser.parse_signature(buffer).each do |decl|
-            yield decl, buffer, file_path, lib_path
-          end
+        path.each_child do |child|
+          each_file(child, immediate: false, skip_hidden: skip_hidden, &block)
         end
-      else
-        enum_for :each_decl
       end
     end
 
-    def load(env:)
-      # @type var loadeds: Array[[AST::Declarations::t, Pathname, path | :stdlib]]
-      loadeds = []
+    def each_decl
+      files = Set[]
 
-      each_decl do |decl, buffer, file_path, lib_path|
-        env.buffers.push(buffer)
-        env << decl
-        loadeds << [decl, file_path, lib_path]
-      end
+      each_dir do |source, dir|
+        skip_hidden = !source.is_a?(Pathname)
+
+        each_file(dir, skip_hidden: skip_hidden, immediate: true) do |path|
+          next if files.include?(path)
 
-      loadeds
+          files << path
+          buffer = Buffer.new(name: path.to_s, content: path.read(encoding: "UTF-8"))
+
+          Parser.parse_signature(buffer).each do |decl|
+            yield decl, buffer, source, path
+          end
+        end
+      end
     end
   end
 end

data/lib/rbs/environment_walker.rb

@@ -1,5 +1,9 @@
 module RBS
   class EnvironmentWalker
+    InstanceNode = Struct.new(:type_name, keyword_init: true)
+    SingletonNode = Struct.new(:type_name, keyword_init: true)
+    TypeNameNode = Struct.new(:type_name, keyword_init: true)
+
     attr_reader :env
 
     def initialize(env:)
@@ -23,54 +27,80 @@ module RBS
     include TSort
 
     def tsort_each_node(&block)
-      env.class_decls.each_key(&block)
-      env.interface_decls.each_key(&block)
-      env.alias_decls.each_key(&block)
+      env.class_decls.each_key do |type_name|
+        yield InstanceNode.new(type_name: type_name)
+        yield SingletonNode.new(type_name: type_name)
+      end
+      env.interface_decls.each_key do |type_name|
+        yield TypeNameNode.new(type_name: type_name)
+      end
+      env.alias_decls.each_key do |type_name|
+        yield TypeNameNode.new(type_name: type_name)
+      end
     end
 
-    def tsort_each_child(name, &block)
+    def tsort_each_child(node, &block)
+      name = node.type_name
+
       unless name.namespace.empty?
-        yield name.namespace.to_type_name
+        yield SingletonNode.new(type_name: name.namespace.to_type_name)
       end
 
-      case
-      when name.class?, name.interface?
-        definitions = []
-
+      case node
+      when TypeNameNode
         case
-        when name.class?
-          definitions << builder.build_instance(name)
-          definitions << builder.build_singleton(name)
         when name.interface?
-          definitions << builder.build_interface(name)
+          definition = builder.build_interface(name)
+          unless only_ancestors?
+            definition.each_type do |type|
+              each_type_node type, &block
+            end
+          end
+        when name.alias?
+          each_type_node builder.expand_alias(name), &block
+        else
+          raise "Unexpected TypeNameNode with type_name=#{name}"
         end
 
-        definitions.each do |definition|
-          if ancestors = definition.ancestors
-            ancestors.ancestors.each do |ancestor|
-              yield ancestor.name
+      when InstanceNode, SingletonNode
+        definition = if node.is_a?(InstanceNode)
+                       builder.build_instance(name)
+                     else
+                       builder.build_singleton(name)
+                     end
 
-              case ancestor
-              when Definition::Ancestor::Instance
+        if ancestors = definition.ancestors
+          ancestors.ancestors.each do |ancestor|
+            case ancestor
+            when Definition::Ancestor::Instance
+              yield InstanceNode.new(type_name: ancestor.name)
+
+              unless only_ancestors?
                 ancestor.args.each do |type|
-                  each_type_name type, &block
+                  each_type_node type, &block
                 end
               end
+            when Definition::Ancestor::Singleton
+              yield SingletonNode.new(type_name: ancestor.name)
             end
           end
+        end
 
-          unless only_ancestors?
-            definition.each_type do |type|
-              each_type_name type, &block
-            end
+        unless only_ancestors?
+          definition.each_type do |type|
+            each_type_node type, &block
           end
         end
-      when name.alias?
-        each_type_name builder.expand_alias(name), &block
       end
     end
 
     def each_type_name(type, &block)
+      each_type_node(type) do |node|
+        yield node.type_name
+      end
+    end
+
+    def each_type_node(type, &block)
       case type
       when RBS::Types::Bases::Any
       when RBS::Types::Bases::Class
@@ -83,29 +113,34 @@ module RBS
       when RBS::Types::Bases::Nil
       when RBS::Types::Variable
       when RBS::Types::ClassSingleton
-        yield type.name
-      when RBS::Types::ClassInstance, RBS::Types::Interface
-        yield type.name
+        yield SingletonNode.new(type_name: type.name)
+      when RBS::Types::ClassInstance
+        yield InstanceNode.new(type_name: type.name)
+        type.args.each do |ty|
+          each_type_node(ty, &block)
+        end
+      when RBS::Types::Interface
+        yield TypeNameNode.new(type_name: type.name)
         type.args.each do |ty|
-          each_type_name(ty, &block)
+          each_type_node(ty, &block)
         end
       when RBS::Types::Alias
-        yield type.name
+        yield TypeNameNode.new(type_name: type.name)
       when RBS::Types::Union, RBS::Types::Intersection, RBS::Types::Tuple
         type.types.each do |ty|
-          each_type_name ty, &block
+          each_type_node ty, &block
         end
       when RBS::Types::Optional
-        each_type_name type.type, &block
+        each_type_node type.type, &block
       when RBS::Types::Literal
         # nop
       when RBS::Types::Record
         type.fields.each_value do |ty|
-          each_type_name ty, &block
+          each_type_node ty, &block
         end
       when RBS::Types::Proc
         type.each_type do |ty|
-          each_type_name ty, &block
+          each_type_node ty, &block
         end
       else
         raise "Unexpected type given: #{type}"