rbs 0.2.0

data/lib/rbs/environment.rb

@@ -0,0 +1,281 @@
+module RBS
+  class Environment
+    attr_reader :buffers
+    attr_reader :declarations
+
+    attr_reader :name_to_decl
+    attr_reader :name_to_extensions
+    attr_reader :name_to_constant
+    attr_reader :name_to_global
+    attr_reader :name_to_alias
+
+    def initialize
+      @buffers = []
+      @declarations = []
+
+      @name_to_decl = {}
+      @name_to_extensions = {}
+      @name_to_constant = {}
+      @name_to_global = {}
+      @name_to_alias = {}
+    end
+
+    def initialize_copy(other)
+      @buffers = other.buffers.dup
+      @declarations = other.declarations.dup
+
+      @name_to_decl = other.name_to_decl.dup
+      @name_to_extensions = other.name_to_extensions.dup
+      @name_to_constant = other.name_to_constant.dup
+      @name_to_global = other.name_to_global.dup
+      @name_to_alias = other.name_to_alias.dup
+    end
+
+    def cache_name(cache, name:, decl:)
+      if cache.key?(name)
+        raise DuplicatedDeclarationError.new(name, decl, cache[name])
+      end
+      cache[name] = decl
+    end
+
+    def <<(decl)
+      declarations << decl
+      case decl
+      when AST::Declarations::Class, AST::Declarations::Module, AST::Declarations::Interface
+        cache_name name_to_decl, name: decl.name.absolute!, decl: decl
+      when AST::Declarations::Extension
+        yield_self do
+          name = decl.name.absolute!
+          exts = name_to_extensions.fetch(name) do
+            name_to_extensions[name] = []
+          end
+          exts << decl
+        end
+      when AST::Declarations::Alias
+        cache_name name_to_alias, name: decl.name.absolute!, decl: decl
+      when AST::Declarations::Constant
+        cache_name name_to_constant, name: decl.name.absolute!, decl: decl
+      when AST::Declarations::Global
+        cache_name name_to_global, name: decl.name, decl: decl
+      end
+    end
+
+    def find_class(type_name)
+      name_to_decl[type_name]
+    end
+
+    def each_decl
+      if block_given?
+        name_to_decl.each do |name, decl|
+          yield name, decl
+        end
+      else
+        enum_for :each_decl
+      end
+    end
+
+    def each_constant
+      if block_given?
+        name_to_constant.each do |name, decl|
+          yield name, decl
+        end
+      else
+        enum_for :each_constant
+      end
+    end
+
+    def each_global
+      if block_given?
+        name_to_global.each do |name, global|
+          yield name, global
+        end
+      else
+        enum_for :each_global
+      end
+    end
+
+    def each_alias(&block)
+      if block_given?
+        name_to_alias.each(&block)
+      else
+        enum_for :each_alias
+      end
+    end
+
+    def each_class_name(&block)
+      each_decl.select {|name,| class?(name) }.each(&block)
+    end
+
+    def class?(type_name)
+      find_class(type_name)&.yield_self do |decl|
+        decl.is_a?(AST::Declarations::Class) || decl.is_a?(AST::Declarations::Module)
+      end
+    end
+
+    def find_type_decl(type_name)
+      name_to_decl[type_name]
+    end
+
+    def find_extensions(type_name)
+      name_to_extensions[type_name] || []
+    end
+
+    def find_alias(type_name)
+      name_to_alias[type_name]
+    end
+
+    def each_extension(type_name, &block)
+      if block_given?
+        (name_to_extensions[type_name] || []).each(&block)
+      else
+        enum_for :each_extension, type_name
+      end
+    end
+
+    def absolute_type_name_in(environment, name:, namespace:)
+      raise "Namespace should be absolute: #{namespace}" unless namespace.absolute?
+
+      if name.absolute?
+        name if environment.key?(name)
+      else
+        absolute_name = name.with_prefix(namespace)
+
+        if environment.key?(absolute_name)
+          absolute_name
+        else
+          if namespace.empty?
+            nil
+          else
+            parent = namespace.parent
+            absolute_type_name_in environment, name: name, namespace: parent
+          end
+        end
+      end
+    end
+
+    def absolute_class_name(name, namespace:)
+      raise "Class name expected: #{name}" unless name.class?
+      absolute_type_name_in name_to_decl, name: name, namespace: namespace
+    end
+
+    def absolute_interface_name(name, namespace:)
+      raise "Interface name expected: #{name}" unless name.interface?
+      absolute_type_name_in name_to_decl, name: name, namespace: namespace
+    end
+
+    def absolute_alias_name(name, namespace:)
+      raise "Alias name expected: #{name}" unless name.alias?
+      absolute_type_name_in name_to_alias, name: name, namespace: namespace
+    end
+
+    def absolute_type_name(type_name, namespace:)
+      absolute_name = case
+                      when type_name.class?
+                        absolute_class_name(type_name, namespace: namespace)
+                      when type_name.alias?
+                        absolute_alias_name(type_name, namespace: namespace)
+                      when type_name.interface?
+                        absolute_interface_name(type_name, namespace: namespace)
+                      end
+
+      absolute_name || yield(type_name)
+    end
+
+    def absolute_name_or(name, type)
+      if name.absolute?
+        type
+      else
+        yield
+      end
+    end
+
+    def absolute_type(type, namespace:, &block)
+      case type
+      when Types::ClassSingleton
+        absolute_name_or(type.name, type) do
+          absolute_name = absolute_type_name(type.name, namespace: namespace) { yield(type) }
+          Types::ClassSingleton.new(name: absolute_name, location: type.location)
+        end
+      when Types::ClassInstance
+        absolute_name = absolute_type_name(type.name, namespace: namespace) { yield(type) }
+        Types::ClassInstance.new(name: absolute_name,
+                                 args: type.args.map {|ty|
+                                   absolute_type(ty, namespace: namespace, &block)
+                                 },
+                                 location: type.location)
+      when Types::Interface
+        absolute_name = absolute_type_name(type.name, namespace: namespace) { yield(type) }
+        Types::Interface.new(name: absolute_name,
+                             args: type.args.map {|ty|
+                               absolute_type(ty, namespace: namespace, &block)
+                             },
+                             location: type.location)
+      when Types::Alias
+        absolute_name_or(type.name, type) do
+          absolute_name = absolute_type_name(type.name, namespace: namespace) { yield(type) }
+          Types::Alias.new(name: absolute_name, location: type.location)
+        end
+      when Types::Tuple
+        Types::Tuple.new(
+          types: type.types.map {|ty| absolute_type(ty, namespace: namespace, &block) },
+          location: type.location
+        )
+      when Types::Record
+        Types::Record.new(
+          fields: type.fields.transform_values {|ty| absolute_type(ty, namespace: namespace, &block) },
+          location: type.location
+        )
+      when Types::Union
+        Types::Union.new(
+          types: type.types.map {|ty| absolute_type(ty, namespace: namespace, &block) },
+          location: type.location
+        )
+      when Types::Intersection
+        Types::Intersection.new(
+          types: type.types.map {|ty| absolute_type(ty, namespace: namespace, &block) },
+          location: type.location
+        )
+      when Types::Optional
+        Types::Optional.new(
+          type: absolute_type(type.type, namespace: namespace, &block),
+          location: type.location
+        )
+      when Types::Proc
+        Types::Proc.new(
+          type: type.type.map_type {|ty| absolute_type(ty, namespace: namespace, &block) },
+          location: type.location
+        )
+      else
+        type
+      end
+    end
+
+    # Validates presence of the relative type, and application arity match.
+    def validate(type, namespace:)
+      case type
+      when Types::ClassInstance, Types::Interface
+        if type.name.namespace.relative?
+          type = absolute_type(type, namespace: namespace) do |type|
+            NoTypeFoundError.check!(type.name.absolute!, env: self, location: type.location)
+          end
+        end
+
+        decl = find_class(type.name)
+        unless decl
+          raise NoTypeFoundError.new(type_name: type.name, location: type.location)
+        end
+
+        InvalidTypeApplicationError.check!(
+          type_name: type.name,
+          args: type.args,
+          params: decl.type_params,
+          location: type.location
+        )
+      end
+
+      type.each_type do |type_|
+        validate(type_, namespace: namespace)
+      end
+    end
+  end
+end

data/lib/rbs/environment_loader.rb

@@ -0,0 +1,136 @@
+module RBS
+  class EnvironmentLoader
+    class UnknownLibraryNameError < StandardError
+      attr_reader :name
+
+      def initialize(name:)
+        @name = name
+        super "Cannot find a library or gem: `#{name}`"
+      end
+    end
+
+    LibraryPath = Struct.new(:name, :path, keyword_init: true)
+    GemPath = Struct.new(:name, :version, :path, keyword_init: true)
+
+    attr_reader :paths
+    attr_reader :stdlib_root
+    attr_reader :gem_vendor_path
+
+    STDLIB_ROOT = Pathname(__dir__) + "../../stdlib"
+
+    def self.gem_sig_path(name, version)
+      Pathname(Gem::Specification.find_by_name(name, version).gem_dir) + "sig"
+    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
+    end
+
+    def add(path: nil, library: nil)
+      case
+      when path
+        @paths << 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
+      end
+    end
+
+    def self.parse_library(lib)
+      lib.split(/:/)
+    end
+
+    def stdlib?(name)
+      if stdlib_root
+        path = stdlib_root + name
+        if path.directory?
+          path
+        end
+      end
+    end
+
+    def gem?(name, version)
+      if gem_vendor_path
+        # Try vendored RBS first
+        gem_dir = gem_vendor_path + name
+        if gem_dir.directory?
+          return gem_dir
+        end
+      end
+
+      # Try ruby gem library
+      self.class.gem_sig_path(name, version)
+    end
+
+    def each_signature(path = nil, immediate: true, &block)
+      if block_given?
+        if path
+          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
+          end
+        else
+          paths.each do |path|
+            case path
+            when Pathname
+              each_signature path, immediate: immediate, &block
+            when LibraryPath
+              each_signature path.path, immediate: immediate, &block
+            when GemPath
+              each_signature path.path, immediate: immediate, &block
+            end
+          end
+        end
+      else
+        enum_for :each_signature, path, immediate: immediate
+      end
+    end
+
+    def no_builtin!
+      @no_builtin = true
+    end
+
+    def no_builtin?
+      @no_builtin
+    end
+
+    def load(env:)
+      signature_files = []
+
+      unless no_builtin?
+        signature_files.push(*each_signature(stdlib_root + "builtin"))
+      end
+
+      each_signature do |path|
+        signature_files.push path
+      end
+
+      signature_files.each do |file|
+        buffer = Buffer.new(name: file.to_s, content: file.read)
+        env.buffers.push(buffer)
+        Parser.parse_signature(buffer).each do |decl|
+          env << decl
+        end
+      end
+    end
+  end
+end

data/lib/rbs/environment_walker.rb

@@ -0,0 +1,124 @@
+module RBS
+  class EnvironmentWalker
+    attr_reader :env
+
+    def initialize(env:)
+      @env = env
+      @only_ancestors = nil
+    end
+
+    def builder
+      @builder ||= DefinitionBuilder.new(env: env)
+    end
+
+    def only_ancestors!(only = true)
+      @only_ancestors = only
+      self
+    end
+
+    def only_ancestors?
+      @only_ancestors
+    end
+
+    include TSort
+
+    def tsort_each_node(&block)
+      env.each_decl do |name|
+        yield name.absolute!
+      end
+
+      env.each_alias do |name, _|
+        yield name.absolute!
+      end
+    end
+
+    def tsort_each_child(name, &block)
+      unless name.namespace.empty?
+        yield name.namespace.to_type_name
+      end
+
+      case
+      when name.class?, name.interface?
+        definitions = []
+
+        case
+        when name.class?
+          definitions << builder.build_instance(name)
+          definitions << builder.build_singleton(name)
+        when name.interface?
+          definitions << builder.build_interface(name, env.find_class(name))
+        end
+
+        definitions.each do |definition|
+          definition.ancestors.each do |ancestor|
+            yield ancestor.name
+
+            case ancestor
+            when Definition::Ancestor::Instance, Definition::Ancestor::ExtensionInstance
+              ancestor.args.each do |type|
+                each_type_name type, &block
+              end
+            end
+          end
+
+          unless only_ancestors?
+            definition.methods.each do |_, method|
+              method.method_types.each do |method_type|
+                method_type.type.each_type do |type|
+                  each_type_name type, &block
+                end
+                method_type.block&.type&.each_type do |type|
+                  each_type_name type, &block
+                end
+              end
+            end
+          end
+        end
+      when name.alias?
+        each_type_name builder.expand_alias(name), &block
+      end
+    end
+
+    def each_type_name(type, &block)
+      case type
+      when RBS::Types::Bases::Any
+      when RBS::Types::Bases::Class
+      when RBS::Types::Bases::Instance
+      when RBS::Types::Bases::Self
+      when RBS::Types::Bases::Top
+      when RBS::Types::Bases::Bottom
+      when RBS::Types::Bases::Bool
+      when RBS::Types::Bases::Void
+      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
+        type.args.each do |ty|
+          each_type_name(ty, &block)
+        end
+      when RBS::Types::Alias
+        yield type.name
+      when RBS::Types::Union, RBS::Types::Intersection, RBS::Types::Tuple
+        type.types.each do |ty|
+          each_type_name ty, &block
+        end
+      when RBS::Types::Optional
+        each_type_name type.type, &block
+      when RBS::Types::Literal
+        # nop
+      when RBS::Types::Record
+        type.fields.each_value do |ty|
+          each_type_name ty, &block
+        end
+      when RBS::Types::Proc
+        type.each_type do |ty|
+          each_type_name ty, &block
+        end
+      else
+        raise "Unexpected type given: #{type}"
+      end
+    end
+  end
+end