rbs 0.2.0

data/lib/rbs/errors.rb

@@ -0,0 +1,187 @@
+module RBS
+  class InvalidTypeApplicationError < StandardError
+    attr_reader :type_name
+    attr_reader :args
+    attr_reader :params
+    attr_reader :location
+
+    def initialize(type_name:, args:, params:, location:)
+      @type_name = type_name
+      @args = args
+      @params = params
+      @location = location
+      super "#{Location.to_string location}: #{type_name} expects parameters [#{params.each.map(&:name).join(", ")}], but given args [#{args.join(", ")}]"
+    end
+
+    def self.check!(type_name:, args:, params:, location:)
+      unless args.size == params.size
+        raise new(type_name: type_name, args: args, params: params, location: location)
+      end
+    end
+  end
+
+  class InvalidExtensionParameterError < StandardError
+    attr_reader :type_name
+    attr_reader :extension_name
+    attr_reader :location
+    attr_reader :extension_params
+    attr_reader :class_params
+
+    def initialize(type_name:, extension_name:, extension_params:, class_params:, location:)
+      @type_name = type_name
+      @extension_name = extension_name
+      @extension_params = extension_params
+      @class_params = class_params
+      @location = location
+
+      super "#{Location.to_string location}: Expected #{class_params.size} parameters to #{type_name} (#{extension_name}) but has #{extension_params.size} parameters"
+    end
+
+    def self.check!(type_name:, extension_name:, extension_params:, class_params:, location:)
+      unless extension_params.size == class_params.size
+        raise new(type_name: type_name,
+                  extension_name: extension_name,
+                  extension_params: extension_params,
+                  class_params: class_params,
+                  location: location)
+      end
+    end
+  end
+
+  class RecursiveAncestorError < StandardError
+    attr_reader :ancestors
+    attr_reader :location
+
+    def initialize(ancestors:, location:)
+      last = case last = ancestors.last
+             when Definition::Ancestor::Singleton
+               "singleton(#{last.name})"
+             when Definition::Ancestor::Instance
+               if last.args.empty?
+                 last.name.to_s
+               else
+                 "#{last.name}[#{last.args.join(", ")}]"
+               end
+             end
+
+      super "#{Location.to_string location}: Detected recursive ancestors: #{last}"
+    end
+
+    def self.check!(self_ancestor, ancestors:, location:)
+      case self_ancestor
+      when Definition::Ancestor::Instance
+        if ancestors.any? {|a| a.is_a?(Definition::Ancestor::Instance) && a.name == self_ancestor.name }
+          raise new(ancestors: ancestors + [self_ancestor], location: location)
+        end
+      when Definition::Ancestor::Singleton
+        if ancestors.include?(self_ancestor)
+          raise new(ancestors: ancestors + [self_ancestor], location: location)
+        end
+      end
+    end
+  end
+
+  class NoTypeFoundError < StandardError
+    attr_reader :type_name
+    attr_reader :location
+
+    def initialize(type_name:, location:)
+      @type_name = type_name
+      @location = location
+
+      super "#{Location.to_string location}: Could not find #{type_name}"
+    end
+
+    def self.check!(type_name, env:, location:)
+      env.find_type_decl(type_name) or
+        raise new(type_name: type_name, location: location)
+
+      type_name
+    end
+  end
+
+  class DuplicatedMethodDefinitionError < StandardError
+    attr_reader :decl
+    attr_reader :location
+
+    def initialize(decl:, name:, location:)
+      decl_str = case decl
+                 when AST::Declarations::Interface, AST::Declarations::Class, AST::Declarations::Module
+                   decl.name.to_s
+                 when AST::Declarations::Extension
+                   "#{decl.name} (#{decl.extension_name})"
+                 end
+
+      super "#{Location.to_string location}: #{decl_str} has duplicated method definition: #{name}"
+    end
+
+    def self.check!(decl:, methods:, name:, location:)
+      if methods.key?(name)
+        raise new(decl: decl, name: name, location: location)
+      end
+    end
+  end
+
+  class UnknownMethodAliasError < StandardError
+    attr_reader :original_name
+    attr_reader :aliased_name
+    attr_reader :location
+
+    def initialize(original_name:, aliased_name:, location:)
+      @original_name = original_name
+      @aliased_name = aliased_name
+      @location = location
+
+      super "#{Location.to_string location}: Unknown method alias name: #{original_name} => #{aliased_name}"
+    end
+
+    def self.check!(methods:, original_name:, aliased_name:, location:)
+      unless methods.key?(original_name)
+        raise new(original_name: original_name, aliased_name: aliased_name, location: location)
+      end
+    end
+  end
+
+  class DuplicatedDeclarationError < StandardError
+    attr_reader :name
+    attr_reader :decls
+
+    def initialize(name, *decls)
+      @name = name
+      @decls = decls
+
+      super "#{Location.to_string decls.last.location}: Duplicated declaration: #{name}"
+    end
+  end
+
+  class InvalidVarianceAnnotationError < StandardError
+    MethodTypeError = Struct.new(:method_name, :method_type, :param, keyword_init: true)
+    InheritanceError = Struct.new(:super_class, :param, keyword_init: true)
+    MixinError = Struct.new(:include_member, :param, keyword_init: true)
+
+    attr_reader :decl
+    attr_reader :errors
+
+    def initialize(decl:, errors:)
+      @decl = decl
+      @errors = errors
+
+      message = [
+        "#{Location.to_string decl.location}: Invalid variance annotation: #{decl.name}"
+      ]
+
+      errors.each do |error|
+        case error
+        when MethodTypeError
+          message << "  MethodTypeError (#{error.param.name}): on `#{error.method_name}` #{error.method_type.to_s} (#{error.method_type.location&.start_line})"
+        when InheritanceError
+          message << "  InheritanceError: #{error.super_class}"
+        when MixinError
+          message << "  MixinError: #{error.include_member.name} (#{error.include_member.location&.start_line})"
+        end
+      end
+
+      super message.join("\n")
+    end
+  end
+end

data/lib/rbs/location.rb

@@ -0,0 +1,102 @@
+module RBS
+  class Location
+    attr_reader :buffer
+    attr_reader :start_pos
+    attr_reader :end_pos
+
+    def initialize(buffer:, start_pos:, end_pos:)
+      @buffer = buffer
+      @start_pos = start_pos
+      @end_pos = end_pos
+    end
+
+    def inspect
+      "#<#{self.class}:#{self.__id__} @buffer=#{buffer.name}, @pos=#{start_pos}...#{end_pos}, source='#{source.lines.first}', start_line=#{start_line}, start_column=#{start_column}>"
+    end
+
+    def name
+      buffer.name
+    end
+
+    def start_line
+      start_loc[0]
+    end
+
+    def start_column
+      start_loc[1]
+    end
+
+    def end_line
+      end_loc[0]
+    end
+
+    def end_column
+      end_loc[1]
+    end
+
+    def start_loc
+      @start_loc ||= buffer.pos_to_loc(start_pos)
+    end
+
+    def end_loc
+      @end_loc ||= buffer.pos_to_loc(end_pos)
+    end
+
+    def source
+      @source ||= buffer.content[start_pos...end_pos]
+    end
+
+    def to_s
+      "#{name || "-"}:#{start_line}:#{start_column}...#{end_line}:#{end_column}"
+    end
+
+    def self.to_string(location, default: "*:*:*...*:*")
+      location&.to_s || default
+    end
+
+    def ==(other)
+      other.is_a?(Location) &&
+        other.buffer == buffer &&
+        other.start_pos == start_pos &&
+        other.end_pos == end_pos
+    end
+
+    def +(other)
+      if other
+        raise "Invalid concat: buffer=#{buffer.name}, other.buffer=#{other.buffer.name}" unless other.buffer == buffer
+
+        self.class.new(buffer: buffer,
+                       start_pos: start_pos,
+                       end_pos: other.end_pos)
+      else
+        self
+      end
+    end
+
+    def self.concat(*locations)
+      locations.inject {|l1, l2| l1 + l2 }
+    end
+
+    def pred?(loc)
+      loc.is_a?(Location) &&
+        loc.name == name &&
+        loc.start_pos == end_pos
+    end
+
+    def to_json(*args)
+      {
+        start: {
+          line: start_line,
+          column: start_column
+        },
+        end: {
+          line: end_line,
+          column: end_column
+        },
+        buffer: {
+          name: name&.to_s
+        }
+      }.to_json(*args)
+    end
+  end
+end

data/lib/rbs/method_type.rb

@@ -0,0 +1,123 @@
+module RBS
+  class MethodType
+    class Block
+      attr_reader :type
+      attr_reader :required
+
+      def initialize(type:, required:)
+        @type = type
+        @required = required
+      end
+
+      def ==(other)
+        other.is_a?(Block) &&
+          other.type == type &&
+          other.required == required
+      end
+
+      def to_json(*a)
+        {
+          type: type,
+          required: required
+        }.to_json(*a)
+      end
+
+      def sub(s)
+        self.class.new(
+          type: type.sub(s),
+          required: required
+        )
+      end
+    end
+
+    attr_reader :type_params
+    attr_reader :type
+    attr_reader :block
+    attr_reader :location
+
+    def initialize(type_params:, type:, block:, location:)
+      @type_params = type_params
+      @type = type
+      @block = block
+      @location = location
+    end
+
+    def ==(other)
+      other.is_a?(MethodType) &&
+        other.type_params == type_params &&
+        other.type == type &&
+        other.block == block
+    end
+
+    def to_json(*a)
+      {
+        type_params: type_params,
+        type: type,
+        block: block,
+        location: location
+      }.to_json(*a)
+    end
+
+    def sub(s)
+      s.without(*type_params).yield_self do |sub|
+        map_type do |ty|
+          ty.sub(sub)
+        end
+      end
+    end
+
+    def update(type_params: self.type_params, type: self.type, block: self.block, location: self.location)
+      self.class.new(
+        type_params: type_params,
+        type: type,
+        block: block,
+        location: location
+      )
+    end
+
+    def free_variables(set = Set.new)
+      type.free_variables(set)
+      block&.type&.free_variables(set)
+      set.subtract(type_params)
+    end
+
+    def map_type(&block)
+      self.class.new(
+        type_params: type_params,
+        type: type.map_type(&block),
+        block: self.block&.yield_self do |b|
+          Block.new(type: b.type.map_type(&block), required: b.required)
+        end,
+        location: location
+      )
+    end
+
+    def each_type(&block)
+      if block_given?
+        type.each_type(&block)
+        self.block&.yield_self do |b|
+          b.type.each_type(&block)
+        end
+      else
+        enum_for :each_type
+      end
+    end
+
+    def to_s
+      s = case
+          when block && block.required
+            "(#{type.param_to_s}) { (#{block.type.param_to_s}) -> #{block.type.return_to_s} } -> #{type.return_to_s}"
+          when block
+            "(#{type.param_to_s}) ?{ (#{block.type.param_to_s}) -> #{block.type.return_to_s} } -> #{type.return_to_s}"
+          else
+            "(#{type.param_to_s}) -> #{type.return_to_s}"
+          end
+
+      if type_params.empty?
+        s
+      else
+        "[#{type_params.join(", ")}] #{s}"
+      end
+    end
+  end
+end

data/lib/rbs/namespace.rb

@@ -0,0 +1,91 @@
+module RBS
+  class Namespace
+    attr_reader :path
+
+    def initialize(path:, absolute:)
+      @path = path
+      @absolute = absolute
+    end
+
+    def self.empty
+      new(path: [], absolute: false)
+    end
+
+    def self.root
+      new(path: [], absolute: true)
+    end
+
+    def +(other)
+      if other.absolute?
+        other
+      else
+        self.class.new(path: path + other.path, absolute: absolute?)
+      end
+    end
+
+    def append(component)
+      self.class.new(path: path + [component], absolute: absolute?)
+    end
+
+    def parent
+      raise "Parent with empty namespace" if empty?
+      self.class.new(path: path.take(path.size - 1), absolute: absolute?)
+    end
+
+    def absolute?
+      @absolute
+    end
+
+    def relative?
+      !absolute?
+    end
+
+    def absolute!
+      self.class.new(path: path, absolute: true)
+    end
+
+    def relative!
+      self.class.new(path: path, absolute: false)
+    end
+
+    def empty?
+      path.empty?
+    end
+
+    def ==(other)
+      other.is_a?(Namespace) && other.path == path && other.absolute? == absolute?
+    end
+
+    alias eql? ==
+
+    def hash
+      self.class.hash ^ path.hash ^ absolute?.hash
+    end
+
+    def split
+      [parent, path.last]
+    end
+
+    def to_s
+      if empty?
+        absolute? ? "::" : ""
+      else
+        s = path.join("::")
+        absolute? ? "::#{s}::" : "#{s}::"
+      end
+    end
+
+    def to_type_name
+      parent, name = split
+      TypeName.new(name: name, namespace: parent)
+    end
+
+    def self.parse(string)
+      if string.start_with?("::")
+        new(path: string.split("::").drop(1).map(&:to_sym), absolute: true)
+      else
+        new(path: string.split("::").map(&:to_sym), absolute: false)
+      end
+    end
+  end
+end