rbs 2.0.0 → 2.2.2

data/docs/stdlib.md

@@ -1,109 +1,10 @@
-# Stdlib Signatures Guide
+# Testing Core API and Standard Library Types
 
-This is a guide for contributing to `rbs` by writing/revising stdlib signatures.
-
-The typical steps of writing signatures will be like the following:
-
-1. Generate a prototype
-2. Import RDoc document
-3. Give correct types to the prototype
-4. Add tests
-
-## Signatures
-
-Signatures for builtin libraries are located in `core` directory. Also, signatures for standard libraries are located in `stdlib` directory.
-
-To write signatures see [syntax guide](syntax.md).
-
-## Generating prototypes
-
-`rbs` provides a tool to generate a prototype of signatures, `rbs prototype`.
-It provides several options, `rbi` from Sorbet RBI files, `rb` from Ruby code, and `runtime` from runtime API.
-`runtime` should be the best option for standard libraries because they may be implemented in C, no Ruby source code.
-
-The tool `require`s all of the libraries specified with `-r` option, and then use introspection APIs like `instance_methods` to know the structure of the class.
-The commandline receives the name of classes you want to prototype, exact class name (like `Pathname`) or pattern with `*` (like `IO::*`).
-
-```
-$ bundle exec rbs prototype runtime --require pathname Pathname
-class Pathname
-  def self.getwd: () -> untyped
-
-  def self.glob: (*untyped) -> untyped
-
-  def self.pwd: () -> untyped
-
-  def +: (untyped other) -> untyped
-
-  alias / +
-
-  def <=>: (untyped) -> untyped
-
-  # snip
-end
-
-# snip
-```
-
-The prototype includes:
-
-* Instance method definitions,
-* Singleton method definitions,
-* Includes, and
-* Constants
-
-It generate a simple prototype in the sense that all of the types included are `untyped`.
-But it will help you to have an overview of the signatures you are trying to write.
-
-### What to do with existing RBS files
-
-Generating prototypes will overwrite existing RBS files, which might be undesirable.
-You can try to find missing parts, or you can start from the scratch.
-
-One non-trivial but absolutely better solution is to make a tool:
-
-1. To load type definitions from existing RBS file, and
-2. Generate prototypes only for missing methods.
-
-## Import RDoc document
-
-The next step should be importing RDoc documents.
-
-```
-$ bin/annotate-with-rdoc stdlib/pathname/0/pathname.rbs
-Loading store from /Users/soutaro/.rbenv/versions/2.7.0-dev/share/ri/2.7.0/system...
-Loading store from /Users/soutaro/.rbenv/versions/2.7.0-dev/share/ri/2.7.0/site...
-Opening stdlib/pathname/pathname.rbs...
-  Importing documentation for Pathname...
-    Processing glob...
-    Processing +...
-    # snip
-Writing stdlib/pathname/pathname.rbs...
-```
-
-The `annotate-with-rdoc` command adds annotations to RBS files.
-
-1. Query RDoc documents to annotate classes, modules, methods, and constants,
-2. Put annotations on RBS AST, and
-3. Update the given .RBS files
-
-We recommend using the command to annotate the RBS files.
-
-## Writing types
-
-The next step is to replace `untyped` types in the prototype.
-See [syntax guide](syntax.md) for the detail of the syntax.
-
-We can show some of the guides for writing types.
-
-1. Use `bool` for truth values, truthy or falsey. More specific types like `TrueClass | FalseClass` may be too strict.
-2. Use `void` if the return value is useless.
-3. Use `nil` instead of `NilClass`.
-4. The most strict types may not be the best types. Use `untyped` if you cannot find the best one.
+This is a guide for testing core/stdlib types.
 
 ## Add Tests
 
-We support writing tests for stdlib signatures.
+We support writing tests for core/stdlib signatures.
 
 ### Writing tests
 

data/docs/syntax.md

@@ -279,13 +279,12 @@ _member_ ::= _ivar-member_                # Ivar definition
            | _extend-member_              # Mixin (extend)
            | _prepend-member_             # Mixin (prepend)
            | _alias-member_               # Alias
-           | `public`                     # Public
-           | `private`                    # Private
+           | _visibility-member_          # Visibility member
 
 _ivar-member_ ::= _ivar-name_ `:` _type_
 
-_method-member_ ::= `def` _method-name_ `:` _method-types_            # Instance method
-                  | `def self.` _method-name_ `:` _method-types_      # Singleton method
+_method-member_ ::= _visibility_ `def` _method-name_ `:` _method-types_            # Instance method
+                  | _visibility_ `def self.` _method-name_ `:` _method-types_      # Singleton method
                   | `def self?.` _method-name_ `:` _method-types_     # Singleton and instance method
 
 _method-types_ ::= _method-type-parameters_ _method-type_                       # Single method type
@@ -295,9 +294,11 @@ _method-types_ ::= _method-type-parameters_ _method-type_
 _method-type-parameters_ ::=                                                    # Empty
                            | `[` _type-variable_ `,` ... `]`
 
-_attribute-member_ ::= _attribute-type_ _method-name_ `:` _type_                     # Attribute
-                     | _attribute-type_ _method-name_ `(` _ivar-name_ `) :` _type_   # Attribute with variable name specification
-                     | _attribute-type_ _method-name_ `() :` _type_                  # Attribute without variable
+_attribute-member_ ::= _visibility_ _attribute-type_ _method-name_ `:` _type_                     # Attribute
+                     | _visibility_ _attribute-type_ _method-name_ `(` _ivar-name_ `) :` _type_   # Attribute with variable name specification
+                     | _visibility_ _attribute-type_ _method-name_ `() :` _type_                  # Attribute without variable
+
+_visibility_ ::= `public` | `private`
 
 _attribute-type_ ::= `attr_reader` | `attr_writer` | `attr_accessor`
 
@@ -310,6 +311,8 @@ _prepend-member_ ::= `prepend` _class-name_ _type-arguments_
 _alias-member_ ::= `alias` _method-name_ _method-name_
                  | `alias self.` _method-name_ `self.` _method-name_
 
+_visibility-member_ ::= _visibility_
+
 _ivar-name_ ::= /@\w+/
 _method-name_ ::= ...
                 | /`[^`]+`/
@@ -328,7 +331,7 @@ An instance variable definition consists of the name of an instance variable and
 
 Method definition has several syntax variations.
 
-You can write `self.` or `self?.` before the name of the method to specify the kind of method: instance, singleton, or both instance and singleton.
+You can write `self.` or `self?.` before the name of the method to specify the kind of method: instance, singleton, or module function.
 
 ```
 def to_s: () -> String                        # Defines a instance method
@@ -336,6 +339,8 @@ def self.new: () -> AnObject                  # Defines singleton method
 def self?.sqrt: (Numeric) -> Numeric          # self? is for `module_function`s
 ```
 
+`self?` method definition adds two methods: a public singleton method and a private instance method, which is equivalent to `module_function` in Ruby.
+
 The method type can be connected with `|`s to define an overloaded method.
 
 ```
@@ -351,6 +356,16 @@ def +: (Float | Integer) -> (Float | Integer)
      | (Numeric) -> Numeric
 ```
 
+Adding `public` and `private` modifier changes the visibility of the method.
+
+```
+private def puts: (*untyped) -> void       # Defines private instance method
+
+public def self.puts: (*untyped) -> void   # Defines public singleton method
+
+public def self?.puts: (*untyped) -> void  # 🚨🚨🚨 Error: `?.` has own visibility semantics (== `module_function`) 🚨🚨🚨
+```
+
 ### Attribute definition
 
 Attribute definitions help to define methods and instance variables based on the convention of `attr_reader`, `attr_writer` and `attr_accessor` methods in Ruby.
@@ -374,6 +389,14 @@ attr_accessor people (): Array[Person]
 # def people=: (Array[Person]) -> Array[Person]
 ```
 
+Attribute definitions can have the `public` and `private` modifiers like method definitions:
+
+```
+private attr_accessor id: Integer
+
+private attr_reader self.name: String
+```
+
 ### Mixin (include), Mixin (extend), Mixin (prepend)
 
 You can define mixins between class and modules.
@@ -402,11 +425,31 @@ def map: [X] () { (String) -> X } -> Array[X]
 alias collect map                                   # `#collect` has the same type with `map`
 ```
 
-### `public`, `private`
+### Visibility member
+
+Visibility member allows specifying the default visibility of instance methods and instance attributes.
+
+```rbs
+public
+
+def foo: () -> void          # public instance method
+
+attr_reader name: String     # public instance attribute
+
+private
 
-`public` and `private` allows specifying the visibility of methods.
+def bar: () -> void          # private instance method
 
-These work only as _statements_, not per-method specifier.
+attr_reader email: String    # private instance attribute
+```
+
+The visibility _modifiers_ overwrite the default visibility per member bases.
+
+The visibility member requires a new line `\n` after the token.
+
+```rbs
+private alias foo bar       # Syntax error
+```
 
 ## Declarations
 

data/ext/rbs_extension/extconf.rb

@@ -1,3 +1,4 @@
 require 'mkmf'
 $INCFLAGS << " -I$(top_srcdir)" if $extmk
+$CFLAGS += " -std=c99 "
 create_makefile 'rbs_extension'

data/ext/rbs_extension/lexer.h

@@ -149,6 +149,11 @@ unsigned int peek(lexstate *state);
  * */
 void skip(lexstate *state);
 
+/**
+ * Skip n characters.
+ * */
+void skipn(lexstate *state, size_t size);
+
 /**
  * Return new token with given type.
  * */

data/ext/rbs_extension/lexstate.c

@@ -134,6 +134,12 @@ void skip(lexstate *state) {
   }
 }
 
+void skipn(lexstate *state, size_t size) {
+  for (size_t i = 0; i < size; i ++) {
+    skip(state);
+  }
+}
+
 char *peek_token(lexstate *state, token tok) {
   return RSTRING_PTR(state->string) + tok.range.start.byte_pos;
 }

data/ext/rbs_extension/parser.c

@@ -1430,6 +1430,8 @@ InstanceSingletonKind parse_instance_singleton_kind(parserstate *state, bool all
 
 /**
  * def_member ::= {kDEF} method_name `:` <method_types>
+ *              | {kPRIVATE2} kDEF method_name `:` <method_types>
+ *              | {kPUBLIC2} kDEF method_name `:` <method_types>
  *
  * method_types ::= {} <method_type>
  *                | {} <`...`>
@@ -1440,30 +1442,61 @@ InstanceSingletonKind parse_instance_singleton_kind(parserstate *state, bool all
  * */
 VALUE parse_member_def(parserstate *state, bool instance_only, bool accept_overload, position comment_pos, VALUE annotations) {
   range member_range;
+  range visibility_range;
   range keyword_range;
   range name_range;
   range kind_range;
   range overload_range = NULL_RANGE;
 
-  keyword_range = state->current_token.range;
-  member_range.start = keyword_range.start;
+  VALUE visibility;
 
-  comment_pos = nonnull_pos_or(comment_pos, keyword_range.start);
+  member_range.start = state->current_token.range.start;
+  comment_pos = nonnull_pos_or(comment_pos, member_range.start);
   VALUE comment = get_comment(state, comment_pos.line);
 
+  switch (state->current_token.type)
+  {
+  case kPRIVATE:
+    visibility_range = state->current_token.range;
+    visibility = ID2SYM(rb_intern("private"));
+    member_range.start = visibility_range.start;
+    parser_advance(state);
+    break;
+  case kPUBLIC:
+    visibility_range = state->current_token.range;
+    visibility = ID2SYM(rb_intern("public"));
+    member_range.start = visibility_range.start;
+    parser_advance(state);
+    break;
+  default:
+    visibility_range = NULL_RANGE;
+    visibility = Qnil;
+    break;
+  }
+
+  keyword_range = state->current_token.range;
+
   InstanceSingletonKind kind;
   if (instance_only) {
     kind_range = NULL_RANGE;
     kind = INSTANCE_KIND;
   } else {
-    kind = parse_instance_singleton_kind(state, true, &kind_range);
+    kind = parse_instance_singleton_kind(state, NIL_P(visibility), &kind_range);
   }
 
   VALUE name = parse_method_name(state, &name_range);
   VALUE method_types = rb_ary_new();
   VALUE overload = Qfalse;
 
-  parser_advance_assert(state, pCOLON);
+  if (state->next_token.type == pDOT && RB_SYM2ID(name) == rb_intern("self?")) {
+    raise_syntax_error(
+      state,
+      state->next_token,
+      "`self?` method cannot have visibility"
+    );
+  } else {
+    parser_advance_assert(state, pCOLON);
+  }
 
   parser_push_typevar_table(state, kind != INSTANCE_KIND);
 
@@ -1533,6 +1566,7 @@ VALUE parse_member_def(parserstate *state, bool instance_only, bool accept_overl
   rbs_loc_add_required_child(loc, rb_intern("name"), name_range);
   rbs_loc_add_optional_child(loc, rb_intern("kind"), kind_range);
   rbs_loc_add_optional_child(loc, rb_intern("overload"), overload_range);
+  rbs_loc_add_optional_child(loc, rb_intern("visibility"), visibility_range);
 
   return rbs_ast_members_method_definition(
     name,
@@ -1541,7 +1575,8 @@ VALUE parse_member_def(parserstate *state, bool instance_only, bool accept_overl
     annotations,
     location,
     comment,
-    overload
+    overload,
+    visibility
   );
 }
 
@@ -1839,10 +1874,14 @@ VALUE parse_visibility_member(parserstate *state, VALUE annotations) {
 
 /*
   attribute_member ::= {attr_keyword} attr_name attr_var `:` <type>
+                     | {visibility} attr_keyword attr_name attr_var `:` <type>
                      | {attr_keyword} `self` `.` attr_name attr_var `:` <type>
+                     | {visibility} attr_keyword `self` `.` attr_name attr_var `:` <type>
 
   attr_keyword ::= `attr_reader` | `attr_writer` | `attr_accessor`
 
+  visibility ::= `public` | `private`
+
   attr_var ::=                    # empty
              | `(` tAIDENT `)`    # Ivar name
              | `(` `)`            # No variable
@@ -1850,7 +1889,7 @@ VALUE parse_visibility_member(parserstate *state, VALUE annotations) {
 VALUE parse_attribute_member(parserstate *state, position comment_pos, VALUE annotations) {
   range member_range;
   range keyword_range, name_range, colon_range;
-  range kind_range = NULL_RANGE, ivar_range = NULL_RANGE, ivar_name_range = NULL_RANGE;
+  range kind_range = NULL_RANGE, ivar_range = NULL_RANGE, ivar_name_range = NULL_RANGE, visibility_range = NULL_RANGE;
 
   InstanceSingletonKind is_kind;
   VALUE klass;
@@ -1860,12 +1899,31 @@ VALUE parse_attribute_member(parserstate *state, position comment_pos, VALUE ann
   VALUE type;
   VALUE comment;
   VALUE location;
+  VALUE visibility;
   rbs_loc *loc;
 
   member_range.start = state->current_token.range.start;
   comment_pos = nonnull_pos_or(comment_pos, member_range.start);
   comment = get_comment(state, comment_pos.line);
 
+  switch (state->current_token.type)
+  {
+  case kPRIVATE:
+    visibility = ID2SYM(rb_intern("private"));
+    visibility_range = state->current_token.range;
+    parser_advance(state);
+    break;
+  case kPUBLIC:
+    visibility = ID2SYM(rb_intern("public"));
+    visibility_range = state->current_token.range;
+    parser_advance(state);
+    break;
+  default:
+    visibility = Qnil;
+    visibility_range = NULL_RANGE;
+    break;
+  }
+
   keyword_range = state->current_token.range;
   switch (state->current_token.type)
   {
@@ -1924,6 +1982,7 @@ VALUE parse_attribute_member(parserstate *state, position comment_pos, VALUE ann
   rbs_loc_add_optional_child(loc, rb_intern("kind"), kind_range);
   rbs_loc_add_optional_child(loc, rb_intern("ivar"), ivar_range);
   rbs_loc_add_optional_child(loc, rb_intern("ivar_name"), ivar_name_range);
+  rbs_loc_add_optional_child(loc, rb_intern("visibility"), visibility_range);
 
   return rbs_ast_members_attribute(
     klass,
@@ -1933,7 +1992,8 @@ VALUE parse_attribute_member(parserstate *state, position comment_pos, VALUE ann
     kind,
     annotations,
     location,
-    comment
+    comment,
+    visibility
   );
 }
 
@@ -2113,7 +2173,6 @@ VALUE parse_module_members(parserstate *state) {
       member = parse_alias_member(state, false, annot_pos, annotations);
       break;
 
-
     case tAIDENT:
     case tA2IDENT:
     case kSELF:
@@ -2128,7 +2187,23 @@ VALUE parse_module_members(parserstate *state) {
 
     case kPUBLIC:
     case kPRIVATE:
-      member = parse_visibility_member(state, annotations);
+      if (state->next_token.range.start.line == state->current_token.range.start.line) {
+        switch (state->next_token.type)
+        {
+        case kDEF:
+          member = parse_member_def(state, false, true, annot_pos, annotations);
+          break;
+        case kATTRREADER:
+        case kATTRWRITER:
+        case kATTRACCESSOR:
+          member = parse_attribute_member(state, annot_pos, annotations);
+          break;
+        default:
+          raise_syntax_error(state, state->next_token, "method or attribute definition is expected after visibility modifier");
+        }
+      } else {
+        member = parse_visibility_member(state, annotations);
+      }
       break;
 
     default:

data/ext/rbs_extension/ruby_objs.c

@@ -400,7 +400,7 @@ VALUE rbs_ast_decl_module(VALUE name, VALUE type_params, VALUE self_types, VALUE
   );
 }
 
-VALUE rbs_ast_members_method_definition(VALUE name, VALUE kind, VALUE types, VALUE annotations, VALUE location, VALUE comment, VALUE overload) {
+VALUE rbs_ast_members_method_definition(VALUE name, VALUE kind, VALUE types, VALUE annotations, VALUE location, VALUE comment, VALUE overload, VALUE visibility) {
   VALUE args = rb_hash_new();
   rb_hash_aset(args, ID2SYM(rb_intern("name")), name);
   rb_hash_aset(args, ID2SYM(rb_intern("kind")), kind);
@@ -409,6 +409,7 @@ VALUE rbs_ast_members_method_definition(VALUE name, VALUE kind, VALUE types, VAL
   rb_hash_aset(args, ID2SYM(rb_intern("location")), location);
   rb_hash_aset(args, ID2SYM(rb_intern("comment")), comment);
   rb_hash_aset(args, ID2SYM(rb_intern("overload")), overload);
+  rb_hash_aset(args, ID2SYM(rb_intern("visibility")), visibility);
 
   return CLASS_NEW_INSTANCE(
     RBS_AST_Members_MethodDefinition,
@@ -446,7 +447,7 @@ VALUE rbs_ast_members_mixin(VALUE klass, VALUE name, VALUE module_args, VALUE an
   );
 }
 
-VALUE rbs_ast_members_attribute(VALUE klass, VALUE name, VALUE type, VALUE ivar_name, VALUE kind, VALUE annotations, VALUE location, VALUE comment) {
+VALUE rbs_ast_members_attribute(VALUE klass, VALUE name, VALUE type, VALUE ivar_name, VALUE kind, VALUE annotations, VALUE location, VALUE comment, VALUE visibility) {
   VALUE args = rb_hash_new();
   rb_hash_aset(args, ID2SYM(rb_intern("name")), name);
   rb_hash_aset(args, ID2SYM(rb_intern("type")), type);
@@ -455,6 +456,7 @@ VALUE rbs_ast_members_attribute(VALUE klass, VALUE name, VALUE type, VALUE ivar_
   rb_hash_aset(args, ID2SYM(rb_intern("annotations")), annotations);
   rb_hash_aset(args, ID2SYM(rb_intern("location")), location);
   rb_hash_aset(args, ID2SYM(rb_intern("comment")), comment);
+  rb_hash_aset(args, ID2SYM(rb_intern("visibility")), visibility);
 
   return CLASS_NEW_INSTANCE(
     klass,

data/ext/rbs_extension/ruby_objs.h

@@ -16,8 +16,8 @@ VALUE rbs_ast_decl_interface(VALUE name, VALUE type_params, VALUE members, VALUE
 VALUE rbs_ast_decl_module_self(VALUE name, VALUE args, VALUE location);
 VALUE rbs_ast_decl_module(VALUE name, VALUE type_params, VALUE self_types, VALUE members, VALUE annotations, VALUE location, VALUE comment);
 VALUE rbs_ast_members_alias(VALUE new_name, VALUE old_name, VALUE kind, VALUE annotations, VALUE location, VALUE comment);
-VALUE rbs_ast_members_attribute(VALUE klass, VALUE name, VALUE type, VALUE ivar_name, VALUE kind, VALUE annotations, VALUE location, VALUE comment);
-VALUE rbs_ast_members_method_definition(VALUE name, VALUE kind, VALUE types, VALUE annotations, VALUE location, VALUE comment, VALUE overload);
+VALUE rbs_ast_members_attribute(VALUE klass, VALUE name, VALUE type, VALUE ivar_name, VALUE kind, VALUE annotations, VALUE location, VALUE comment, VALUE visibility);
+VALUE rbs_ast_members_method_definition(VALUE name, VALUE kind, VALUE types, VALUE annotations, VALUE location, VALUE comment, VALUE overload, VALUE visibility);
 VALUE rbs_ast_members_mixin(VALUE klass, VALUE name, VALUE args, VALUE annotations, VALUE location, VALUE comment);
 VALUE rbs_ast_members_variable(VALUE klass, VALUE name, VALUE type, VALUE location, VALUE comment);
 VALUE rbs_ast_members_visibility(VALUE klass, VALUE location);

data/goodcheck.yml

@@ -1,15 +1,4 @@
 rules:
-  - id: rbs.no_mark
-    pattern: 💪👽🚨
-    message: Do you forget to delete `arglists` section?
-    glob:
-      - "{core,stdlib}/**/*.rbs"
-    fail:
-      - |
-        # arglists 💪👽🚨 << Delete this section
-        #    File.absolute_path?(file_name)  ->  true or false
-        #
-
   - id: rbs.no_arg
     pattern:
       regexp: arg\d+