rbs 1.0.3 → 1.1.1

data/lib/rbs/parser.y

@@ -760,8 +760,8 @@ rule
         location = val[0].location + val[1].location
         result = Types::Tuple.new(types: [], location: location)
       }
-    | kLBRACKET type_list kRBRACKET {
-        location = val[0].location + val[2].location
+    | kLBRACKET type_list comma_opt kRBRACKET {
+        location = val[0].location + val[3].location
         types = val[1]
         result = Types::Tuple.new(types: types, location: location)
       }
@@ -794,10 +794,10 @@ rule
       }
 
   record_type:
-      kLBRACE record_fields kRBRACE {
+      kLBRACE record_fields comma_opt kRBRACE {
         result = Types::Record.new(
           fields: val[1],
-          location: val[0].location + val[2].location
+          location: val[0].location + val[3].location
         )
       }
 
@@ -805,7 +805,7 @@ rule
       record_field {
         result = val[0]
       }
-    | record_field kCOMMA record_fields {
+    | record_fields kCOMMA record_field {
         result = val[0].merge!(val[2])
       }
 
@@ -1062,6 +1062,10 @@ rule
         namespace = Namespace.parse(val[0].value)
         result = LocatedValue.new(value: namespace, location: val[0].location)
       }
+
+  comma_opt:
+      kCOMMA | # empty
+
 end
 
 ---- inner
@@ -1084,8 +1088,6 @@ class LocatedValue
   end
 end
 
-require "strscan"
-
 attr_reader :input
 attr_reader :buffer
 attr_reader :eof_re
@@ -1094,7 +1096,7 @@ def initialize(type, buffer:, eof_re:)
   super()
   @type = type
   @buffer = buffer
-  @input = StringScanner.new(buffer.content)
+  @input = CharScanner.new(buffer.content)
   @eof_re = eof_re
   @eof = false
   @bound_variables_stack = []
@@ -1210,11 +1212,7 @@ def new_token(type, value = input.matched)
 end
 
 def charpos(scanner)
-  if @ascii_only
-    scanner.pos
-  else
-    scanner.charpos
-  end
+  scanner.charpos
 end
 
 def empty_params_result
@@ -1421,7 +1419,11 @@ def next_token
     s = input.matched.yield_self {|s| s[1, s.length - 2] }.gsub(/\\'/, "'")
     new_token(:tSTRING, s)
   else
-    raise "Unexpected token: #{input.peek(10)}..."
+    text = input.peek(10)
+    start_index = charpos(input)
+    end_index = start_index + text.length
+    location = RBS::Location.new(buffer: buffer, start_pos: start_index, end_pos: end_index)
+    raise LexerError.new(input: text, location: location)
   end
 end
 
@@ -1429,7 +1431,7 @@ def on_error(token_id, error_value, value_stack)
   raise SyntaxError.new(token_str: token_to_str(token_id), error_value: error_value, value_stack: value_stack)
 end
 
-class SyntaxError < StandardError
+class SyntaxError < ParsingError
   attr_reader :token_str, :error_value, :value_stack
 
   def initialize(token_str:, error_value:, value_stack: nil)
@@ -1441,7 +1443,7 @@ class SyntaxError < StandardError
   end
 end
 
-class SemanticsError < StandardError
+class SemanticsError < ParsingError
   attr_reader :subject, :location, :original_message
 
   def initialize(message, subject:, location:)
@@ -1453,4 +1455,15 @@ class SemanticsError < StandardError
   end
 end
 
+class LexerError < ParsingError
+  attr_reader :location, :input
+
+  def initialize(input:, location:)
+    @input = input
+    @location = location
+
+    super "Unexpected string: #{input}..."
+  end
+end
+
 ---- footer

data/lib/rbs/test/type_check.rb

@@ -5,13 +5,17 @@ module RBS
       attr_reader :builder
       attr_reader :sample_size
       attr_reader :unchecked_classes
+      attr_reader :instance_class
+      attr_reader :class_class
 
       attr_reader :const_cache
 
       DEFAULT_SAMPLE_SIZE = 100
 
-      def initialize(self_class:, builder:, sample_size:, unchecked_classes:)
+      def initialize(self_class:, builder:, sample_size:, unchecked_classes:, instance_class: Object, class_class: Module)
         @self_class = self_class
+        @instance_class = instance_class
+        @class_class = class_class
         @builder = builder
         @sample_size = sample_size
         @unchecked_classes = unchecked_classes.uniq
@@ -237,9 +241,9 @@ module RBS
         when Types::Bases::Nil
           Test.call(val, IS_AP, ::NilClass)
         when Types::Bases::Class
-          Test.call(val, IS_AP, Class)
+          Test.call(val, IS_AP, class_class)
         when Types::Bases::Instance
-          Test.call(val, IS_AP, self_class)
+          Test.call(val, IS_AP, instance_class)
         when Types::ClassInstance
           klass = get_class(type.name) or return false
           case

data/lib/rbs/version.rb

@@ -1,3 +1,3 @@
 module RBS
-  VERSION = "1.0.3"
+  VERSION = "1.1.1"
 end

data/sig/ancestor_graph.rbs

@@ -0,0 +1,40 @@
+module RBS
+  class AncestorGraph
+    class InstanceNode
+      attr_reader type_name: TypeName
+      def initialize: (type_name: TypeName) -> void
+    end
+
+    class SingletonNode
+      attr_reader type_name: TypeName
+      def initialize: (type_name: TypeName) -> void
+    end
+
+    type node = InstanceNode | SingletonNode
+
+    attr_reader env: Environment
+    attr_reader ancestor_builder: DefinitionBuilder::AncestorBuilder
+    attr_reader parents: Hash[node, Set[node]]
+    attr_reader children: Hash[node, Set[node]]
+
+    def initialize: (env: Environment, ?ancestor_builder: DefinitionBuilder::AncestorBuilder) -> void
+
+    def build: () -> void
+
+    def each_parent: (node) { (node) -> void } -> void
+                   | (node) -> Enumerator[node, void]
+
+    def each_ancestor: (node, ?yielded: Set[node]) { (node) -> void } -> void
+                     | (node) -> Enumerator[node, void]
+
+    def each_child: (node) { (node) -> void } -> void
+                  | (node) -> Enumerator[node, void]
+
+    def each_descendant: (node, ?yielded: Set[node]) { (node) -> void } -> void
+                       | (node) -> Enumerator[node, void]
+
+    def build_ancestors: (node, DefinitionBuilder::AncestorBuilder::OneAncestors) -> void
+
+    def register: (parent: node, child: node) -> void
+  end
+end

data/sig/char_scanner.rbs

@@ -0,0 +1,9 @@
+module RBS
+  class CharScanner < StringScanner
+    def initialize: (String) -> void
+
+    def original_charpos: () -> Integer
+
+    @charpos: Integer
+  end
+end

data/sig/definition_builder.rbs

@@ -10,7 +10,7 @@ module RBS
     attr_reader singleton0_cache: Hash[TypeName, Definition | false | nil]
     attr_reader interface_cache: Hash[TypeName, Definition | false | nil]
 
-    def initialize: (env: Environment) -> void
+    def initialize: (env: Environment, ?ancestor_builder: AncestorBuilder?, ?method_builder: MethodBuilder?) -> void
 
     def validate_super_class!: (TypeName, Environment::ClassEntry) -> void
 
@@ -42,5 +42,9 @@ module RBS
     def insert_variable: (TypeName, Hash[Symbol, Definition::Variable], name: Symbol, type: Types::t) -> void
 
     def define_methods: (Definition, interface_methods: Hash[Symbol, Definition::Method], methods: MethodBuilder::Methods, super_interface_method: bool) -> void
+
+    def expand_alias: (TypeName) -> Types::t
+
+    def update: (env: Environment, ancestor_builder: AncestorBuilder, except: _Each[TypeName]) -> DefinitionBuilder
   end
 end

data/sig/environment.rbs

@@ -58,7 +58,7 @@ module RBS
       def initialize: (name: N, decl: D, outer: Array[module_decl]) -> void
     end
 
-    attr_reader buffers: Array[Buffer]
+    # Top level declarations.
     attr_reader declarations: Array[AST::Declarations::t]
 
     attr_reader class_decls: Hash[TypeName, ModuleEntry | ClassEntry]
@@ -77,9 +77,20 @@ module RBS
 
     def insert_decl: (AST::Declarations::t, outer: Array[module_decl], namespace: Namespace) -> void
 
+    # Insert a toplevel declaration into the env.
+    #
     def <<: (AST::Declarations::t decl) -> self
 
-    def resolve_type_names: () -> Environment
+    # Runs generics type params validation over each class definitions.
+    def validate_type_params: () -> void
+
+    # Resolve all type names in the environment to absolute type names.
+    # Relative type name will be left if absolute type name cannot be found.
+    #
+    # When `only` is given, it skips other _top-level_ declarations not included in the collection.
+    # This helps running resolution faster in the case of _partial updates_.
+    #
+    def resolve_type_names: (?only: Set[AST::Declarations::t]?) -> Environment
 
     def resolve_declaration: (TypeNameResolver resolver, AST::Declarations::t decl, outer: Array[module_decl], prefix: Namespace) -> AST::Declarations::t
 
@@ -90,5 +101,14 @@ module RBS
     def absolute_type_name: (TypeNameResolver, TypeName, context: Array[Namespace]) -> TypeName
 
     def inspect: () -> String
+
+    def buffers: () -> Array[Buffer]
+
+    def buffers_decls: () -> Hash[Buffer, Array[AST::Declarations::t]]
+
+    # Construct new environment without declarations tested `true` by block.
+    # Construction of new environment is done with `<<` so that nested declarations will work well.
+    #
+    def reject: () { (AST::Declarations::t) -> boolish } -> Environment
   end
 end

data/sig/environment_walker.rbs

@@ -0,0 +1,39 @@
+module RBS
+  class EnvironmentWalker
+    class InstanceNode
+      attr_reader type_name: TypeName
+      def initialize: (type_name: TypeName) -> void
+    end
+
+    class SingletonNode
+      attr_reader type_name: TypeName
+      def initialize: (type_name: TypeName) -> void
+    end
+
+    class TypeNameNode
+      attr_reader type_name: TypeName
+      def initialize: (type_name: TypeName) -> void
+    end
+
+    attr_reader env: Environment
+    attr_reader only_ancestors: bool
+    attr_reader builder: DefinitionBuilder
+
+    def initialize: (env: Environment) -> void
+
+    def only_ancestors!: (?bool only) -> self
+
+    def only_ancestors?: () -> bool
+
+    type node = InstanceNode | SingletonNode | TypeNameNode
+    include TSort[node]
+
+    def tsort_each_node: () { (node) -> void } -> void
+
+    def tsort_each_child: (node) { (node) -> void } -> void
+
+    def each_type_name: (Types::t) { (TypeName) -> void } -> void
+
+    def each_type_node: (Types::t) { (node) -> void } -> void
+  end
+end

data/sig/errors.rbs

@@ -11,7 +11,27 @@ module RBS
     def method_name_string: () -> String
   end
 
-  class InvalidTypeApplicationError < StandardError
+  # Error class for errors defined in RBS.
+  #
+  class BaseError < StandardError
+  end
+
+  # Error class for errors raised during parsing.
+  #
+  class ParsingError < BaseError
+  end
+
+  # Error class for errors raised during loading environments.
+  #
+  class LoadingError < BaseError
+  end
+
+  # Error class for errors raised during building definitions.
+  #
+  class DefinitionError < BaseError
+  end
+
+  class InvalidTypeApplicationError < DefinitionError
     attr_reader type_name: TypeName
     attr_reader args: Array[Types::t]
     attr_reader params: Array[Symbol]
@@ -22,16 +42,16 @@ module RBS
     def self.check!: (type_name: TypeName, args: Array[Types::t], params: Array[Symbol], location: Location?) -> void
   end
 
-  class RecursiveAncestorError < StandardError
+  class RecursiveAncestorError < DefinitionError
     attr_reader ancestors: Array[Definition::Ancestor::t]
-    attr_reader location: Location
+    attr_reader location: Location?
 
     def initialize: (ancestors: Array[Definition::Ancestor::t], location: Location?) -> void
 
     def self.check!: (Definition::Ancestor::t, ancestors: Array[Definition::Ancestor::t], location: Location?) -> void
   end
 
-  class NoTypeFoundError < StandardError
+  class NoTypeFoundError < DefinitionError
     attr_reader type_name: TypeName
     attr_reader location: Location?
 
@@ -40,7 +60,7 @@ module RBS
     def self.check!: (TypeName, env: Environment, location: Location?) -> TypeName
   end
 
-  class NoSuperclassFoundError < StandardError
+  class NoSuperclassFoundError < DefinitionError
     attr_reader type_name: TypeName
     attr_reader location: Location?
 
@@ -49,7 +69,7 @@ module RBS
     def self.check!: (TypeName, env: Environment, location: Location?) -> void
   end
 
-  class NoSelfTypeFoundError < StandardError
+  class NoSelfTypeFoundError < DefinitionError
     attr_reader type_name: TypeName
     attr_reader location: Location?
 
@@ -58,7 +78,7 @@ module RBS
     def self.check!: (AST::Declarations::Module::Self, env: Environment) -> void
   end
 
-  class NoMixinFoundError < StandardError
+  class NoMixinFoundError < DefinitionError
     attr_reader type_name: TypeName
     attr_reader member: AST::Members::t
 
@@ -69,7 +89,7 @@ module RBS
     def self.check!: (TypeName, env: Environment, member: AST::Members::t) -> void
   end
 
-  class DuplicatedMethodDefinitionError < StandardError
+  class DuplicatedMethodDefinitionError < DefinitionError
     type ty = Types::ClassSingleton | Types::ClassInstance | Types::Interface
     type original = DefinitionBuilder::MethodBuilder::Methods::Definition::original
 
@@ -79,6 +99,8 @@ module RBS
 
     def initialize: (type: ty, method_name: Symbol, members: Array[original]) -> void
 
+    def type_name: () -> TypeName
+
     def qualified_method_name: () -> String
 
     def location: () -> Location?
@@ -86,7 +108,7 @@ module RBS
     def other_locations: () -> Array[Location?]
   end
 
-  class DuplicatedInterfaceMethodDefinitionError < StandardError
+  class DuplicatedInterfaceMethodDefinitionError < DefinitionError
     type ty = Types::ClassSingleton | Types::ClassInstance | Types::Interface
     type mixin_member = AST::Members::Include | AST::Members::Extend
 
@@ -96,25 +118,28 @@ module RBS
 
     def initialize: (type: ty, method_name: Symbol, member: mixin_member) -> void
 
+    def type_name: () -> TypeName
+
     def qualified_method_name: () -> String
   end
 
-  class UnknownMethodAliasError < StandardError
+  class UnknownMethodAliasError < DefinitionError
+    attr_reader type_name: TypeName
     attr_reader original_name: Symbol
     attr_reader aliased_name: Symbol
     attr_reader location: Location?
 
-    def initialize: (original_name: Symbol, aliased_name: Symbol, location: Location?) -> void
+    def initialize: (type_name: TypeName, original_name: Symbol, aliased_name: Symbol, location: Location?) -> void
   end
 
-  class SuperclassMismatchError < StandardError
+  class SuperclassMismatchError < DefinitionError
     attr_reader name: TypeName
     attr_reader entry: Environment::ClassEntry
 
     def initialize: (name: TypeName, entry: Environment::ClassEntry) -> void
   end
 
-  class InvalidOverloadMethodError < StandardError
+  class InvalidOverloadMethodError < DefinitionError
     attr_reader type_name: TypeName
     attr_reader method_name: Symbol
     attr_reader kind: :instance | :singleton
@@ -123,21 +148,21 @@ module RBS
     def initialize: (type_name: TypeName, method_name: Symbol, kind: :instance | :singleton, members: Array[AST::Members::MethodDefinition]) -> void
   end
 
-  class GenericParameterMismatchError < StandardError
+  class GenericParameterMismatchError < LoadingError
     attr_reader name: TypeName
     attr_reader decl: AST::Declarations::Class | AST::Declarations::Module
 
     def initialize: (name: TypeName, decl: AST::Declarations::Class | AST::Declarations::Module) -> void
   end
 
-  class DuplicatedDeclarationError < StandardError
+  class DuplicatedDeclarationError < LoadingError
     attr_reader name: TypeName | Symbol
     attr_reader decls: Array[AST::Declarations::t]
 
     def initialize: (TypeName | Symbol, *AST::Declarations::t) -> void
   end
 
-  class InvalidVarianceAnnotationError < StandardError
+  class InvalidVarianceAnnotationError < DefinitionError
     attr_reader type_name: TypeName
     attr_reader param: AST::Declarations::ModuleTypeParams::TypeParam
     attr_reader location: Location?
@@ -145,7 +170,7 @@ module RBS
     def initialize: (type_name: TypeName, param: AST::Declarations::ModuleTypeParams::TypeParam, location: Location?) -> void
   end
 
-  class RecursiveAliasDefinitionError < StandardError
+  class RecursiveAliasDefinitionError < DefinitionError
     type ty = Types::ClassInstance | Types::ClassSingleton | Types::Interface
     type defn = DefinitionBuilder::MethodBuilder::Methods::Definition