rbs 2.7.0 → 2.8.0.pre.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d5774c0ae32533d1da69481ae4b413817580fd9974b445a67bef1faf4ff48080
-  data.tar.gz: 3f4552b3a91d2fc233f110b8682b73674454163a540d271c9f355daf6e61b5d3
+  metadata.gz: a1d6bcfbb96db1bd762270824620e4a430057521398fdef7d8543cceaaaab127
+  data.tar.gz: 4616fee00017d88cb942fa34f25dee2bd1959ba83bf3f8eedf7f57770792d2e0
 SHA512:
-  metadata.gz: '0827ff2d63c104b99b07b5319f581b559b6dd7b6e9a26ae2f65d2fc5f8b9c435fff19690b9efe1dfed4c5d220c61c4afdb74203a2275b27bd95a934fbe467c16'
-  data.tar.gz: 7584c2471066032562ca5c3eb39dc8880e764f0fa880fcb9d1ee5e5b56b29fad9d2991b570b17ccf8b9e1f9ecf395c4719609d176dc2058fce6bfac03455d79f
+  metadata.gz: 9bfb3f1cb6ed463fbc9d78181b6fdd683bbb476adfdbda4ef7a1009d8c225ee96f7f5d958dbba3d2f5b461f2253ad0d27e68072653efde251886550cf64973c3
+  data.tar.gz: bb8b7a2984b4211d8bbb19d213b999f78caa9e676fef3584da29b49a18639362f2884233337e1c5aedad01ce495055085ae080df81f696ce135de1220638d34a

data/CHANGELOG.md

@@ -2,6 +2,35 @@
 
 ## master
 
+## 2.8.0.pre.1 (2022-11-17)
+
+### Signature updates
+
+* `IO` ([#1132](https://github.com/ruby/rbs/pull/1132))
+* `IO::Buffer` ([#1137](https://github.com/ruby/rbs/pull/1137))
+* `IPAddr` ([#1131](https://github.com/ruby/rbs/pull/1131), [#1151](https://github.com/ruby/rbs/pull/1151))
+* `Socket` ([#1133](https://github.com/ruby/rbs/pull/1133), [#1134](https://github.com/ruby/rbs/pull/1134), [#1151](https://github.com/ruby/rbs/pull/1151))
+* `Yaml` ([#1141](https://github.com/ruby/rbs/pull/1141))
+
+### Library changes
+
+* Make type/method-type parser more flexible about input position ([#1140](https://github.com/ruby/rbs/pull/1140))
+* Raise an error if a class definition inherits a module ([#1152](https://github.com/ruby/rbs/pull/1152))
+* Fix SEGV when parse with invalid content ([#1146](https://github.com/ruby/rbs/pull/1146))
+
+#### rbs collection
+
+* Support to call collection command in child dir ([#1025](https://github.com/ruby/rbs/pull/1025), [#1135](https://github.com/ruby/rbs/pull/1135))
+
+### Miscellaneous
+
+* Remove `rubygems` from `rbs`’s manifest ([#1150](https://github.com/ruby/rbs/pull/1150))
+* Use `untyped` instead of `any` in `syntax.md` ([#1147](https://github.com/ruby/rbs/pull/1147))
+* Fix typo and grammatical mistakes in "Generics" section of `syntax.md` ([#1127](https://github.com/ruby/rbs/pull/1127))
+* Add a doc that describes tools related to RBS ([#1125](https://github.com/ruby/rbs/pull/1125))
+* Add self-type-bindings to `syntax.md` ([#1123](https://github.com/ruby/rbs/pull/1123))
+* Add documentation for `...` in `syntax.md` ([#1120](https://github.com/ruby/rbs/pull/1120))
+
 ## 2.7.0 (2022-10-07)
 
 ### Signature updates

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    rbs (2.7.0)
+    rbs (2.8.0.pre.1)
 
 PATH
   remote: test/assets/test-gem
@@ -47,32 +47,32 @@ GEM
       rake
     rdoc (6.4.0)
       psych (>= 4.0.0)
-    regexp_parser (2.5.0)
+    regexp_parser (2.6.0)
     rexml (3.2.5)
-    rspec (3.11.0)
-      rspec-core (~> 3.11.0)
-      rspec-expectations (~> 3.11.0)
-      rspec-mocks (~> 3.11.0)
-    rspec-core (3.11.0)
-      rspec-support (~> 3.11.0)
-    rspec-expectations (3.11.0)
+    rspec (3.12.0)
+      rspec-core (~> 3.12.0)
+      rspec-expectations (~> 3.12.0)
+      rspec-mocks (~> 3.12.0)
+    rspec-core (3.12.0)
+      rspec-support (~> 3.12.0)
+    rspec-expectations (3.12.0)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.11.0)
-    rspec-mocks (3.11.1)
+      rspec-support (~> 3.12.0)
+    rspec-mocks (3.12.0)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.11.0)
-    rspec-support (3.11.0)
-    rubocop (1.36.0)
+      rspec-support (~> 3.12.0)
+    rspec-support (3.12.0)
+    rubocop (1.38.0)
       json (~> 2.3)
       parallel (~> 1.10)
       parser (>= 3.1.2.1)
       rainbow (>= 2.2.2, < 4.0)
       regexp_parser (>= 1.8, < 3.0)
       rexml (>= 3.2.5, < 4.0)
-      rubocop-ast (>= 1.20.1, < 2.0)
+      rubocop-ast (>= 1.23.0, < 2.0)
       ruby-progressbar (~> 1.7)
       unicode-display_width (>= 1.4.0, < 3.0)
-    rubocop-ast (1.21.0)
+    rubocop-ast (1.23.0)
       parser (>= 3.1.1.0)
     rubocop-rubycw (0.1.6)
       rubocop (~> 1.0)
@@ -80,13 +80,13 @@ GEM
       rake (>= 0.8.1)
     ruby-progressbar (1.11.0)
     singleton (0.1.1)
-    stackprof (0.2.21)
+    stackprof (0.2.22)
     stringio (3.0.2)
     strong_json (2.1.2)
     tempfile (0.1.2)
     test-unit (3.5.5)
       power_assert
-    unicode-display_width (2.2.0)
+    unicode-display_width (2.3.0)
 
 PLATFORMS
   ruby

data/Steepfile

@@ -9,14 +9,12 @@ target :lib do
     "lib/rbs/test.rb"
   )
 
-  library "set", "pathname", "json", "logger", "monitor", "tsort", "uri", 'yaml', 'dbm', 'pstore', 'singleton', 'shellwords', 'fileutils', 'find', 'digest'
+  library "set", "pathname", "json", "logger", "monitor", "tsort", "uri", 'dbm', 'pstore', 'singleton', 'shellwords', 'fileutils', 'find', 'digest'
+  signature 'stdlib/yaml/0'
   signature "stdlib/strscan/0/"
   signature "stdlib/optparse/0/"
   signature "stdlib/rdoc/0/"
 
-  # Please remove the following line after releasing #1107
-  signature "core/rubygems/"
-
   configure_code_diagnostics do |config|
     config[D::Ruby::MethodDefinitionMissing] = :hint
     config[D::Ruby::ElseOnExhaustiveCase] = :hint

data/core/io/buffer.rbs

@@ -706,5 +706,20 @@ class IO
     PRIVATE: Integer
 
     READONLY: Integer
+
+    class LockedError < RuntimeError
+    end
+
+    class AllocationError < RuntimeError
+    end
+
+    class AccessError < RuntimeError
+    end
+
+    class InvalidatedError < RuntimeError
+    end
+
+    class MaskError < ArgumentError
+    end
   end
 end

data/core/io.rbs

@@ -2984,6 +2984,12 @@ IO::TRUNC: Integer
 
 IO::WRONLY: Integer
 
+IO::READABLE: Integer
+
+IO::WRITABLE: Integer
+
+IO::PRIORITY: Integer
+
 # <!-- rdoc-file=io.c -->
 # exception to wait for reading by EAGAIN. see IO.select.
 #

data/docs/syntax.md

@@ -3,18 +3,17 @@
 ## Types
 
 ```markdown
-_type_ ::= _class-name_ _type-arguments_                (Class instance type)
-         | _interface-name_ _type-arguments_            (Interface type)
-         | _alias-name_ _type-arguments_                (Alias type)
-         | `singleton(` _class-name_ `)`                (Class singleton type)
-         | _literal_                                    (Literal type)
-         | _type_ `|` _type_                            (Union type)
-         | _type_ `&` _type_                            (Intersection type)
-         | _type_ `?`                                   (Optional type)
-         | `{` _record-name_ `:` _type_ `,` etc. `}`    (Record type)
-         | `[]` | `[` _type_ `,` etc. `]`               (Tuples)
-         | _type-variable_                              (Type variables)
-         | `^(` _parameters_ `) ->` _type_              (Proc type)
+_type_ ::= _class-name_ _type-arguments_                 (Class instance type)
+         | _interface-name_ _type-arguments_             (Interface type)
+         | _alias-name_ _type-arguments_                 (Alias type)
+         | `singleton(` _class-name_ `)`                 (Class singleton type)
+         | _literal_                                     (Literal type)
+         | _type_ `|` _type_                             (Union type)
+         | _type_ `&` _type_                             (Intersection type)
+         | _type_ `?`                                    (Optional type)
+         | `{` _record-name_ `:` _type_ `,` etc. `}`     (Record type)
+         | `[]` | `[` _type_ `,` etc. `]`                (Tuples)
+         | _type-variable_                               (Type variables)
          | `self`
          | `instance`
          | `class`
@@ -24,6 +23,7 @@ _type_ ::= _class-name_ _type-arguments_                (Class instance type)
          | `top`
          | `bot`
          | `void`
+         | _proc_                                        (Proc type)
 
 _class-name_ ::= _namespace_ /[A-Z]\w*/
 _interface-name_ ::= _namespace_ /_[A-Z]\w*/
@@ -43,6 +43,8 @@ _literal_ ::= _string-literal_
             | _integer-literal_
             | `true`
             | `false`
+
+_proc_ ::= _parameters?_ _self-type-binding?_ _block?_ `->` _type_
 ```
 
 ### Class instance type
@@ -164,15 +166,6 @@ class Ref[T]              # Object is scoped in the class declaration.
 end
 ```
 
-### Proc type
-
-Proc type denotes type of procedures, `Proc` instances.
-
-```
-^(Integer) -> String                  # A procedure with an `Integer` parameter and returns `String`
-^(?String, size: Integer) -> bool     # A procedure with `String` optional parameter, `size` keyword of `Integer`, and returns `bool`
-```
-
 ### Base types
 
 `self` denotes the type of receiver. The type is used to model the open recursion via `self`.
@@ -221,14 +214,28 @@ They are all equivalent for the type system; they are all _top type_.
 
 `void` tells developers a hint that _the value should not be used_. `boolish` implies the value is used as a truth value. `top` is anything else.
 
-## Method Types
+### Proc type
+
+Proc type denotes type of procedures, `Proc` instances.
+
+```
+^(Integer) -> String                  # A procedure with an `Integer` parameter and returns `String`
+^(?String, size: Integer) -> bool     # A procedure with `String` optional parameter, `size` keyword of `Integer`, and returns `bool`
+```
+
+See the next section for details.
+
+## Method Types and Proc Types
 
 ```markdown
-_method-type_ ::= `(` _parameters_ `) ->` _type_                                       # Method without block
-                | `(` _parameters_ `) { (` _parameters_ `) -> ` _type_ `} ->` _type_   # Method with required block
-                | `(` _parameters_ `) ?{ (` _parameters_ `) -> ` _type_ `} ->` _type_  # Method with optional block
+_method-type_ ::= _parameters?_ _block?_ `->` _type_                # Method type
+
+_proc_ ::= `^` _parameters?_ _self-type-binding?_ _block?_ `->` _type_  # Proc type
 
-_parameters_ ::= _required-positionals_ _optional-positionals_ _rest-positional_ _trailing-positionals_ _keywords_
+_parameters?_ ::=                   (Empty)
+                | _parameters_      (Parameters)
+
+_parameters_ ::= `(` _required-positionals_ _optional-positionals_ _rest-positional_ _trailing-positionals_ _keywords_ `)`
 
 _parameter_ ::= _type_ _var-name_                                  # Parameter with var name
               | _type_                                             # Parameter without var name
@@ -243,6 +250,13 @@ _keywords_ ::=                                                     # Empty
              | `?` _keyword_ `:` _parameter_ `,` _keywords_        # Optional keyword
 
 _var-name_ ::= /[a-z]\w*/
+
+_self-type-binding?_ =                              (Empty)
+                     | `[` `self` `:` _type_ `]`    (Self type binding)
+
+_block?_ =                                                           (No block)
+         | `{` _parameters_ _self-type-binding?_ `->` _type_ `}`      (Block)
+         | `?` `{` _parameters_ _self-type-binding?_ `->` _type_ `}`  (Optional block)
 ```
 
 ### Parameters
@@ -250,7 +264,7 @@ _var-name_ ::= /[a-z]\w*/
 A parameter can be a type or a pair of type and variable name.
 Variable name can be used for documentation.
 
-### Examples
+#### Examples
 
 ```
 # Two required positional `Integer` parameters, and returns `String`
@@ -269,6 +283,29 @@ Variable name can be used for documentation.
 (size: Integer sz, ?name: String, ?created_at: Time?) -> void
 ```
 
+### Self type binding
+
+Self type binding represents the type of methods that uses `#instance_eval`, which replaces the value of `self` inside blocks.
+
+```ruby
+123.instance_eval do
+  self + 1        # self is `123` here
+end
+```
+
+Proc types and blocks can have self type bindings.
+
+```rbs
+^(Integer) [self: String] -> void                                     # Proc type with self type binding
+^(Integer) [self: String] { (Symbol) [self: bool] -> void } -> void   # Proc type with self type binding of `String` and a block with self type binding of `bool`
+```
+
+Method type can have blocks with self type bindings.
+
+```rbs
+() { (Integer) [self: String] -> void } -> void     # A method type with block with self type binding
+```
+
 ## Members
 
 ```markdown
@@ -349,6 +386,14 @@ def +: (Float) -> Float
      | (Numeric) -> Numeric
 ```
 
+Overloaded method can have `...` to overload an existing method. It is useful for monkey-patching.
+
+```
+def +: (Float) -> Float
+def +: (BigDecimal) -> BigDecimal
+     | ...
+```
+
 You need extra parentheses on return type to avoid ambiguity.
 
 ```
@@ -516,7 +561,7 @@ Interface declaration can have parameters but allows only a few of the members.
 ```
 interface _Hashing
   def hash: () -> Integer
-  def eql?: (any) -> bool
+  def eql?: (untyped) -> bool
 end
 ```
 
@@ -574,8 +619,8 @@ _generics-bound_ ::=                       (No type bound)
                    | `<` _bound-type_      (The generics parameter is bounded)
 
 _bound-type_ ::= _class-name_ _type-arguments_       (Class instance type)
-              | _interface-name_ _type-arguments_    (Interface type)
-              | `singleton(` _class-name_ `)`        (Class singleton type)
+               | _interface-name_ _type-arguments_   (Interface type)
+               | `singleton(` _class-name_ `)`       (Class singleton type)
 
 _generics-variance_ ::=               (Invariant)
                       | `out`         (Covariant)
@@ -607,8 +652,8 @@ class Array[out T]
 end
 ```
 
-There's a limitation with this is for mutable objects (like arrays): a mutation could invalidate this.
-If an array of `String` is passed to a method as an array of `Objects`, and that method adds an Integer to the array, the promise is broken.
+There's a limitation with this for mutable objects (like arrays): a mutation could invalidate this.
+If an `Array` of `String` is passed to a method as an `Array` of `Object`, and that method adds an `Integer` to the `Array`, the promise is broken.
 
 In those cases, one must use the `unchecked` keyword:
 

data/docs/tools.md

@@ -0,0 +1,16 @@
+# Tools
+
+This documentation describes major tools related to RBS. They are listed alphabetically.
+
+## Type Checkers
+
+* [Steep](https://github.com/soutaro/steep) is a static type checker based on RBS. You can use it as a language server integrated with an editor or IDE and run it from the command line.
+* [TypeProf](https://github.com/ruby/typeprof)
+
+## Editor integrations
+
+* Emacs: [rbs-mode](https://github.com/ybiquitous/rbs-mode)
+* RubyMine: [It supports RBS by default](https://www.jetbrains.com/help/ruby/rbs.html)
+* Sublime Text: [sublime-rbs-plugin](https://github.com/soutaro/sublime-rbs-plugin)
+* Vim: [rbs.vim](https://github.com/pocke/rbs.vim)
+* Visual Studio Code: [vscode-rbs-syntax](https://github.com/soutaro/vscode-rbs-syntax)

data/ext/rbs_extension/lexer.h

@@ -119,6 +119,8 @@ typedef struct {
  * */
 typedef struct {
   VALUE string;
+  int start_pos;                  /* The character position that defines the start of the input */
+  int end_pos;                    /* The character position that defines the end of the input */
   position current;               /* The current position */
   position start;                 /* The start position of the current token */
   bool first_token_of_line;       /* This flag is used for tLINECOMMENT */

data/ext/rbs_extension/lexstate.c

@@ -100,9 +100,14 @@ int token_bytes(token tok) {
 }
 
 unsigned int peek(lexstate *state) {
-  unsigned int c = rb_enc_mbc_to_codepoint(RSTRING_PTR(state->string) + state->current.byte_pos, RSTRING_END(state->string), rb_enc_get(state->string));
-  state->last_char = c;
-  return c;
+  if (state->current.char_pos == state->end_pos) {
+    state->last_char = '\0';
+    return 0;
+  } else {
+    unsigned int c = rb_enc_mbc_to_codepoint(RSTRING_PTR(state->string) + state->current.byte_pos, RSTRING_END(state->string), rb_enc_get(state->string));
+    state->last_char = c;
+    return c;
+  }
 }
 
 token next_token(lexstate *state, enum TokenType type) {
@@ -137,6 +142,7 @@ void skip(lexstate *state) {
 
 void skipn(lexstate *state, size_t size) {
   for (size_t i = 0; i < size; i ++) {
+    peek(state);
     skip(state);
   }
 }

data/ext/rbs_extension/parser.c

@@ -2502,12 +2502,19 @@ VALUE parse_signature(parserstate *state) {
 }
 
 static VALUE
-rbsparser_parse_type(VALUE self, VALUE buffer, VALUE line, VALUE column, VALUE variables)
+rbsparser_parse_type(VALUE self, VALUE buffer, VALUE start_pos, VALUE end_pos, VALUE variables, VALUE requires_eof)
 {
-  parserstate *parser = alloc_parser(buffer, FIX2INT(line), FIX2INT(column), variables);
+  parserstate *parser = alloc_parser(buffer, FIX2INT(start_pos), FIX2INT(end_pos), variables);
+
+  if (parser->next_token.type == pEOF) {
+    return Qnil;
+  }
 
   VALUE type = parse_type(parser);
-  parser_advance_assert(parser, pEOF);
+
+  if (RTEST(requires_eof)) {
+    parser_advance_assert(parser, pEOF);
+  }
 
   free_parser(parser);
 
@@ -2515,19 +2522,29 @@ rbsparser_parse_type(VALUE self, VALUE buffer, VALUE line, VALUE column, VALUE v
 }
 
 static VALUE
-rbsparser_parse_method_type(VALUE self, VALUE buffer, VALUE line, VALUE column, VALUE variables)
+rbsparser_parse_method_type(VALUE self, VALUE buffer, VALUE start_pos, VALUE end_pos, VALUE variables, VALUE requires_eof)
 {
-  parserstate *parser = alloc_parser(buffer, FIX2INT(line), FIX2INT(column), variables);
+  parserstate *parser = alloc_parser(buffer, FIX2INT(start_pos), FIX2INT(end_pos), variables);
+
+  if (parser->next_token.type == pEOF) {
+    return Qnil;
+  }
+
   VALUE method_type = parse_method_type(parser);
-  free(parser);
+
+  if (RTEST(requires_eof)) {
+    parser_advance_assert(parser, pEOF);
+  }
+
+  free_parser(parser);
 
   return method_type;
 }
 
 static VALUE
-rbsparser_parse_signature(VALUE self, VALUE buffer, VALUE line, VALUE column)
+rbsparser_parse_signature(VALUE self, VALUE buffer, VALUE end_pos)
 {
-  parserstate *parser = alloc_parser(buffer, FIX2INT(line), FIX2INT(column), Qnil);
+  parserstate *parser = alloc_parser(buffer, 0, FIX2INT(end_pos), Qnil);
   VALUE signature = parse_signature(parser);
   free_parser(parser);
 
@@ -2536,7 +2553,7 @@ rbsparser_parse_signature(VALUE self, VALUE buffer, VALUE line, VALUE column)
 
 void rbs__init_parser(void) {
   RBS_Parser = rb_define_class_under(RBS, "Parser", rb_cObject);
-  rb_define_singleton_method(RBS_Parser, "_parse_type", rbsparser_parse_type, 4);
-  rb_define_singleton_method(RBS_Parser, "_parse_method_type", rbsparser_parse_method_type, 4);
-  rb_define_singleton_method(RBS_Parser, "_parse_signature", rbsparser_parse_signature, 3);
+  rb_define_singleton_method(RBS_Parser, "_parse_type", rbsparser_parse_type, 5);
+  rb_define_singleton_method(RBS_Parser, "_parse_method_type", rbsparser_parse_method_type, 5);
+  rb_define_singleton_method(RBS_Parser, "_parse_signature", rbsparser_parse_signature, 2);
 }

data/ext/rbs_extension/parserstate.c

@@ -272,13 +272,17 @@ VALUE comment_to_ruby(comment *com, VALUE buffer) {
   );
 }
 
-parserstate *alloc_parser(VALUE buffer, int line, int column, VALUE variables) {
+parserstate *alloc_parser(VALUE buffer, int start_pos, int end_pos, VALUE variables) {
   VALUE string = rb_funcall(buffer, rb_intern("content"), 0);
 
+  StringValue(string);
+
   lexstate *lexer = calloc(1, sizeof(lexstate));
   lexer->string = string;
-  lexer->current.line = line;
-  lexer->current.column = column;
+  lexer->current.line = 1;
+  lexer->start_pos = start_pos;
+  lexer->end_pos = end_pos;
+  skipn(lexer, start_pos);
   lexer->start = lexer->current;
   lexer->first_token_of_line = lexer->current.column == 0;
 

data/ext/rbs_extension/parserstate.h

@@ -101,7 +101,7 @@ bool parser_typevar_member(parserstate *state, ID id);
  * alloc_parser(buffer, 3, 5, Qnil)         // New parserstate without variables
  * ```
  * */
-parserstate *alloc_parser(VALUE buffer, int line, int column, VALUE variables);
+parserstate *alloc_parser(VALUE buffer, int start_pos, int end_pos, VALUE variables);
 void free_parser(parserstate *parser);
 /**
  * Advance one token.

data/lib/rbs/cli.rb

@@ -19,7 +19,7 @@ module RBS
 
         @libs = []
         @dirs = []
-        @config_path = Collection::Config::PATH
+        @config_path = Collection::Config.find_config_path || Collection::Config::PATH
       end
 
       def loader
@@ -1034,16 +1034,17 @@ EOB
       opts.order args.drop(1), into: params
       config_path = options.config_path or raise
       lock_path = Collection::Config.to_lockfile_path(config_path)
+      gemfile_lock_path = Bundler.default_lockfile
 
       case args[0]
       when 'install'
         unless params[:frozen]
-          Collection::Config.generate_lockfile(config_path: config_path, gemfile_lock_path: Pathname('./Gemfile.lock'))
+          Collection::Config.generate_lockfile(config_path: config_path, gemfile_lock_path: gemfile_lock_path)
         end
         Collection::Installer.new(lockfile_path: lock_path, stdout: stdout).install_from_lockfile
       when 'update'
         # TODO: Be aware of argv to update only specified gem
-        Collection::Config.generate_lockfile(config_path: config_path, gemfile_lock_path: Pathname('./Gemfile.lock'), with_lockfile: false)
+        Collection::Config.generate_lockfile(config_path: config_path, gemfile_lock_path: gemfile_lock_path, with_lockfile: false)
         Collection::Installer.new(lockfile_path: lock_path, stdout: stdout).install_from_lockfile
       when 'init'
         if config_path.exist?

data/lib/rbs/collection/config/lockfile_generator.rb

@@ -2,10 +2,24 @@
 
 module RBS
   module Collection
-
-    # This class represent the configration file.
     class Config
       class LockfileGenerator
+        class GemfileLockMismatchError < StandardError
+          def initialize(expected:, actual:)
+            @expected = expected
+            @actual = actual
+          end
+
+          def message
+            <<~MESSAGE
+              RBS Collection loads a different Gemfile.lock from before.
+              The Gemfile.lock must be the same as that is recorded in rbs_collection.lock.yaml.
+              Expected Gemfile.lock: #{@expected}
+              Actual Gemfile.lock: #{@actual}
+            MESSAGE
+          end
+        end
+
         attr_reader :config, :lock, :gemfile_lock, :lock_path
 
         def self.generate(config_path:, gemfile_lock_path:, with_lockfile: true)
@@ -18,6 +32,10 @@ module RBS
           @lock = Config.from_path(lock_path) if lock_path.exist? && with_lockfile
           @gemfile_lock = Bundler::LockfileParser.new(gemfile_lock_path.read)
           @gem_queue = []
+
+          validate_gemfile_lock_path!(lock: lock, gemfile_lock_path: gemfile_lock_path)
+
+          config.gemfile_lock_path = gemfile_lock_path
         end
 
         def generate
@@ -38,6 +56,14 @@ module RBS
           config
         end
 
+        private def validate_gemfile_lock_path!(lock:, gemfile_lock_path:)
+          return unless lock
+          return unless lock.gemfile_lock_path
+          return if lock.gemfile_lock_path == gemfile_lock_path
+
+          raise GemfileLockMismatchError.new(expected: lock.gemfile_lock_path, actual: gemfile_lock_path)
+        end
+
         private def assign_gem(name:, version:)
           # @type var locked: gem_entry?
           locked = lock&.gem(name)

data/lib/rbs/collection/config.rb

@@ -16,6 +16,17 @@ module RBS
 
       PATH = Pathname('rbs_collection.yaml')
 
+      def self.find_config_path
+        current = Pathname.pwd
+
+        loop do
+          config_path = current.join(PATH)
+          return config_path if config_path.exist?
+          current = current.join('..')
+          return nil if current.root?
+        end
+      end
+
       # Generate a rbs lockfile from Gemfile.lock to `config_path`.
       # If `with_lockfile` is true, it respects existing rbs lockfile.
       def self.generate_lockfile(config_path:, gemfile_lock_path:, with_lockfile: true)
@@ -69,6 +80,16 @@ module RBS
         @data['gems'] ||= []
       end
 
+      def gemfile_lock_path=(path)
+        @data['gemfile_lock_path'] = path.relative_path_from(@config_path.dirname).to_s
+      end
+
+      def gemfile_lock_path
+        path = @data['gemfile_lock_path']
+        return unless path
+        @config_path.dirname.join path
+      end
+
       # It raises an error when there are non-available libraries
       def check_rbs_availability!
         raise CollectionNotAvailable unless repo_path.exist?

data/lib/rbs/definition_builder/ancestor_builder.rb

@@ -211,6 +211,9 @@ module RBS
             end
 
             NoSuperclassFoundError.check!(super_name, env: env, location: primary.decl.location)
+            if super_class
+              InheritModuleError.check!(super_class, env: env)
+            end
 
             ancestors = OneAncestors.class_instance(
               type_name: type_name,
@@ -268,6 +271,9 @@ module RBS
             end
 
             NoSuperclassFoundError.check!(super_name, env: env, location: primary.decl.location)
+            if super_class
+              InheritModuleError.check!(super_class, env: env)
+            end
 
             ancestors = OneAncestors.singleton(
               type_name: type_name,