rbs 0.13.1 → 0.14.0

data/lib/rbs/parser.y

@@ -1,5 +1,6 @@
 class RBS::Parser
-  token tUIDENT tLIDENT tNAMESPACE tINTERFACEIDENT tLKEYWORD tUKEYWORD tGLOBALIDENT
+  token tUIDENT tLIDENT tNAMESPACE tINTERFACEIDENT tGLOBALIDENT
+        tLKEYWORD tUKEYWORD tLKEYWORD_Q_E tUKEYWORD_Q_E
         tIVAR tCLASSVAR
         tANNOTATION
         tSTRING tSYMBOL tINTEGER tWRITE_ATTR
@@ -846,7 +847,7 @@ rule
         result = val[0]
       }
 
-  keyword: tLKEYWORD | tUKEYWORD
+  keyword: tLKEYWORD | tUKEYWORD | tLKEYWORD_Q_E | tUKEYWORD_Q_E
 
   function_type:
       kLPAREN params kRPAREN kARROW simple_type {
@@ -1344,8 +1345,12 @@ def next_token
     new_token(:tNAMESPACE)
   when input.scan(/[a-z_]\w*:/)
     new_token(:tLKEYWORD, input.matched.chop.to_sym)
+  when input.scan(/[a-z_]\w*[?!]:/)
+    new_token(:tLKEYWORD_Q_E, input.matched.chop.to_sym)
   when input.scan(/[A-Z]\w*:/)
     new_token(:tUKEYWORD, input.matched.chop.to_sym)
+  when input.scan(/[A-Z]\w*[?!]:/)
+    new_token(:tUKEYWORD_Q_E, input.matched.chop.to_sym)
   when input.scan(/\$[A-Za-z_]\w*/)
     new_token(:tGLOBALIDENT)
   when input.scan(/@[a-zA-Z_]\w*/)

data/lib/rbs/test/setup_helper.rb

@@ -3,15 +3,15 @@ module RBS
     module SetupHelper
       class InvalidSampleSizeError < StandardError
         attr_reader :string
-        
+
         def initialize(string)
           @string = string
           super("Sample size should be a positive integer: `#{string}`")
         end
       end
-      
+
       DEFAULT_SAMPLE_SIZE = 100
-      
+
       def get_sample_size(string)
         case string
         when ""
@@ -32,7 +32,7 @@ module RBS
         when 'rspec'
           ['::RSpec::Mocks::Double']
         when 'minitest'
-          ['::Minitest::Mock'] 
+          ['::Minitest::Mock']
         else
           RBS.logger.warn "Unknown test suite - defaults to nil"
           nil

data/lib/rbs/test/type_check.rb

@@ -212,7 +212,7 @@ module RBS
       def value(val, type)
         if is_double?(val)
           RBS.logger.info("A double (#{val.inspect}) is detected!")
-          return true 
+          return true
         end
 
         case type
@@ -306,7 +306,7 @@ module RBS
           Test.call(val, IS_AP, ::Array) &&
             type.types.map.with_index {|ty, index| value(val[index], ty) }.all?
         when Types::Record
-          Test::call(val, IS_AP, ::Hash) && 
+          Test::call(val, IS_AP, ::Hash) &&
             type.fields.map {|key, type| value(val[key], type) }.all?
         when Types::Proc
           Test::call(val, IS_AP, ::Proc)

data/lib/rbs/type_name.rb

@@ -23,7 +23,7 @@ module RBS
     def ==(other)
       other.is_a?(self.class) && other.namespace == namespace && other.name == name
     end
-    
+
     alias eql? ==
 
     def hash

data/lib/rbs/variance_calculator.rb

@@ -135,7 +135,7 @@ module RBS
                   when :contravariant
                     :covariant
                   else
-                    raise                    
+                    raise
                   end
             type(ty, result: result, context: con)
           end

data/lib/rbs/version.rb

@@ -1,3 +1,3 @@
 module RBS
-  VERSION = "0.13.1"
+  VERSION = "0.14.0"
 end

data/lib/rbs/writer.rb

@@ -305,7 +305,7 @@ module RBS
       if prev_loc && decl_loc
         prev_end_line = prev_loc.end_line
         start_line = decl_loc.start_line
-  
+
         if start_line - prev_end_line > 1
           puts
         end

data/sig/constant.rbs

@@ -11,9 +11,9 @@ module RBS
     attr_reader entry: constant_entry
 
     def initialize: (name: TypeName, type: Types::t, entry: constant_entry) -> void
-                  
+
     def ==: (untyped other) -> bool
-          
+
     alias eql? ==
 
     def hash: () -> Integer

data/sig/constant_table.rbs

@@ -6,25 +6,25 @@ module RBS
     attr_reader env(): Environment
 
     def initialize: (builder: DefinitionBuilder) -> void
-                  
+
     def absolute_type: (Types::t, context: Array[Namespace]) -> Types::t
-                     
+
     def absolute_type_name: (TypeName, context: Array[Namespace], location: Location?) -> TypeName
-                          
+
     def name_to_constant: (TypeName) -> Constant?
-                        
+
     def split_name: (TypeName) -> Array[Symbol]
-                  
+
     def resolve_constant_reference: (TypeName name, context: Array[Namespace]) -> Constant?
-                                  
+
     def resolve_constant_reference_context: (Symbol, context: Array[Namespace]) -> Constant?
-                                          
+
     def resolve_constant_reference_inherit: (Symbol, scopes: Array[Namespace], ?no_object: bool) -> Constant?
-                                          
+
     def constant_scopes: (TypeName) -> Array[Namespace]
-                       
+
     def constant_scopes_module: (TypeName, scopes: Array[Namespace]) -> Array[Namespace]
-                       
+
     def constant_scopes0: (TypeName, ?scopes: Array[Namespace]) -> Array[Namespace]
   end
 end

data/sig/declarations.rbs

@@ -2,7 +2,7 @@ module RBS
   module AST
     module Declarations
       type t = Class | Module | Interface | Constant | Global | Alias
-      
+
       class Base
       end
 

data/sig/definition.rbs

@@ -28,7 +28,7 @@ module RBS
         def annotations: () -> Array[AST::Annotation]
 
         def update: (?type: MethodType, ?member: method_member, ?defined_in: TypeName?, ?implemented_in: TypeName?) -> TypeDef
-        
+
         def overload?: () -> bool
       end
 

data/sig/namespace.rbs

@@ -1,6 +1,6 @@
 module RBS
   # Namespace instance represents a _prefix of module names_.
-  # 
+  #
   #    vvvvvvvvvvvvvv  TypeName
   #    RBS::Namespace
   #    ^^^^^           Namespace
@@ -44,7 +44,7 @@ module RBS
     # If `other` is an absolute namespace, it returns `other`.
     #
     #   Namespace("Foo::") + Namespace("::Bar::")  # =>  ::Bar::
-    # 
+    #
     def +: (Namespace other) -> Namespace
 
     # Add one path component to self.
@@ -62,7 +62,7 @@ module RBS
 
     # Returns true if self is absolute namespace.
     def absolute?: () -> bool
-    
+
     # Returns true if self is relative namespace.
     def relative?: () -> bool
 

data/sig/parser.rbs

@@ -0,0 +1,25 @@
+module RBS
+  class Parser
+    class SyntaxError < StandardError
+      attr_reader token_str: String
+      attr_reader error_value: untyped
+      attr_reader value_stack: untyped?
+
+      def initialize: (token_str: String, error_value: untyped, ?value_stack: untyped?) -> void
+    end
+
+    class SemanticsError < StandardError
+      attr_reader subject: untyped
+      attr_reader location: Location
+      attr_reader original_message: String
+
+      def initialize: (String message, subject: untyped, location: Location) -> void
+    end
+
+    def self.parse_method_type: (String | Buffer, ?variables: Array[Symbol], ?eof_re: Regexp?) -> MethodType
+                              
+    def self.parse_type: (String | Buffer, ?variables: Array[Symbol], ?eof_re: Regexp?) -> Types::t
+                       
+    def self.parse_signature: (String | Buffer, ?eof_re: Regexp?) -> Array[AST::Declarations::t]
+  end
+end

data/sig/substitution.rbs

@@ -1,6 +1,6 @@
 module RBS
   # Substitution from type variables to types.
-  # 
+  #
   # The substitution construction is in _destructive_ manner.
   #
   #    sub = Substitution.new
@@ -25,7 +25,7 @@ module RBS
     # Utility method to construct a substitution.
     # Raises an error when `variables.size != types.size`.
     # `instance_type` defaults to `nil`.
-    # 
+    #
     # Yields types in `types` and the block value is used if block is given.
     #
     def self.build: (Array[Symbol] variables, Array[Types::t] types, ?instance_type: Types::t?) ?{ (Types::t) -> Types::t } -> instance
@@ -36,4 +36,4 @@ module RBS
     # Returns a substitution without variables given in `vars`.
     def without: (*Symbol vars) -> Substitution
   end
-end
+end

data/sig/typename.rbs

@@ -1,6 +1,6 @@
 module RBS
   # TypeName represents name of types in RBS.
-  # 
+  #
   # TypeNames are one of the three kind, class, alias, and interface.
   # *class* type names corresponds to Ruby classes and modules.
   # There are no corresponding Ruby value to *alias* and *interface* type names.

data/sig/types.rbs

@@ -154,7 +154,7 @@ module RBS
 
       include NoFreeVariables
       include NoSubst
-      include EmptyEachType      
+      include EmptyEachType
     end
 
     module Application

data/sig/writer.rbs

@@ -4,37 +4,37 @@ module RBS
     attr_reader indentation: Array[String]
 
     def initialize: (out: IO) -> void
-                  
+
     def indent: (?Integer size) { () -> void } -> void
-              
+
     def prefix: () -> String
-              
+
     def puts: (?String) -> void
-            
+
     def write_annotation: (Array[AST::Annotation]) -> void
-                        
+
     def write_comment: (AST::Comment?) -> void
-                     
+
     def write: (Array[AST::Declarations::t]) -> void
-             
+
     def write_decl: (AST::Declarations::t) -> void
-                  
+
     def write_member: (AST::Declarations::Module::member) -> void
-                  
+
     def name_and_params: (TypeName, AST::Declarations::ModuleTypeParams) -> String?
-                       
+
     def name_and_args: (TypeName, Array[Types::t]) -> String?
-                     
+
     def method_name: (Symbol) -> String
-                   
+
     def write_def: (AST::Members::MethodDefinition) -> void
-                 
+
     def attribute: (:reader | :writer | :accessor, AST::Members::Attribute) -> void
-                 
+
     interface _Located
       def location: () -> Location?
     end
-                 
+
     def preserve_empty_line: (_Located?, _Located) -> void
   end
 end

data/stdlib/benchmark/benchmark.rbs

@@ -53,9 +53,9 @@
 #     times:    1.000000   0.000000   1.000000 (  1.003611)
 #     upto:     1.030000   0.000000   1.030000 (  1.028098)
 #
-# *   The times for some benchmarks depend on the order in which items are run. 
+# *   The times for some benchmarks depend on the order in which items are run.
 #     These differences are due to the cost of memory allocation and garbage
-#     collection. To avoid these discrepancies, the #bmbm method is provided. 
+#     collection. To avoid these discrepancies, the #bmbm method is provided.
 #     For example, to compare ways to sort an array of floats:
 #
 #         require 'benchmark'

data/stdlib/builtin/basic_object.rbs

@@ -1,108 +1,108 @@
 # BasicObject is the parent class of all classes in Ruby.  It's an explicit
 # blank class.
-# 
+#
 # BasicObject can be used for creating object hierarchies independent of Ruby's
 # object hierarchy, proxy objects like the Delegator class, or other uses where
 # namespace pollution from Ruby's methods and classes must be avoided.
-# 
+#
 # To avoid polluting BasicObject for other users an appropriately named subclass
 # of BasicObject should be created instead of directly modifying BasicObject:
-# 
+#
 #     class MyObjectSystem < BasicObject
 #     end
-# 
+#
 # BasicObject does not include Kernel (for methods like `puts`) and BasicObject
 # is outside of the namespace of the standard library so common classes will not
 # be found without using a full class path.
-# 
+#
 # A variety of strategies can be used to provide useful portions of the standard
 # library to subclasses of BasicObject.  A subclass could `include Kernel` to
 # obtain `puts`, `exit`, etc.  A custom Kernel-like module could be created and
 # included or delegation can be used via #method_missing:
-# 
+#
 #     class MyObjectSystem < BasicObject
 #       DELEGATE = [:puts, :p]
-# 
+#
 #       def method_missing(name, *args, &block)
 #         super unless DELEGATE.include? name
 #         ::Kernel.send(name, *args, &block)
 #       end
-# 
+#
 #       def respond_to_missing?(name, include_private = false)
 #         DELEGATE.include?(name) or super
 #       end
 #     end
-# 
+#
 # Access to classes and modules from the Ruby standard library can be obtained
 # in a BasicObject subclass by referencing the desired constant from the root
 # like `::File` or `::Enumerator`. Like #method_missing, #const_missing can be
 # used to delegate constant lookup to `Object`:
-# 
+#
 #     class MyObjectSystem < BasicObject
 #       def self.const_missing(name)
 #         ::Object.const_get(name)
 #       end
 #     end
-# 
+#
 class BasicObject
   # Boolean negate.
-  # 
+  #
   def !: () -> bool
 
   # Returns true if two objects are not-equal, otherwise false.
-  # 
+  #
   def !=: (untyped other) -> bool
 
   # Equality --- At the `Object` level, `==` returns `true` only if `obj` and
   # `other` are the same object. Typically, this method is overridden in
   # descendant classes to provide class-specific meaning.
-  # 
+  #
   # Unlike `==`, the `equal?` method should never be overridden by subclasses as
   # it is used to determine object identity (that is, `a.equal?(b)` if and only if
   # `a` is the same object as `b`):
-  # 
+  #
   #     obj = "a"
   #     other = obj.dup
-  # 
+  #
   #     obj == other      #=> true
   #     obj.equal? other  #=> false
   #     obj.equal? obj    #=> true
-  # 
+  #
   # The `eql?` method returns `true` if `obj` and `other` refer to the same hash
   # key.  This is used by Hash to test members for equality.  For objects of class
   # `Object`, `eql?` is synonymous with `==`.  Subclasses normally continue this
   # tradition by aliasing `eql?` to their overridden `==` method, but there are
   # exceptions.  `Numeric` types, for example, perform type conversion across
   # `==`, but not across `eql?`, so:
-  # 
+  #
   #     1 == 1.0     #=> true
   #     1.eql? 1.0   #=> false
-  # 
+  #
   def ==: (untyped other) -> bool
 
   # Returns an integer identifier for `obj`.
-  # 
+  #
   # The same number will be returned on all calls to `object_id` for a given
   # object, and no two active objects will share an id.
-  # 
+  #
   # Note: that some objects of builtin classes are reused for optimization. This
   # is the case for immediate values and frozen string literals.
-  # 
+  #
   # Immediate values are not passed by reference but are passed by value: `nil`,
   # `true`, `false`, Fixnums, Symbols, and some Floats.
-  # 
+  #
   #     Object.new.object_id  == Object.new.object_id  # => false
   #     (21 * 2).object_id    == (21 * 2).object_id    # => true
   #     "hello".object_id     == "hello".object_id     # => false
   #     "hi".freeze.object_id == "hi".freeze.object_id # => true
-  # 
+  #
   def __id__: () -> Integer
 
   # Invokes the method identified by *symbol*, passing it any arguments specified.
   # You can use `__send__` if the name `send` clashes with an existing method in
   # *obj*. When the method is identified by a string, the string is converted to a
   # symbol.
-  # 
+  #
   #     class Klass
   #       def hello(*args)
   #         "Hello " + args.join(' ')
@@ -110,48 +110,48 @@ class BasicObject
   #     end
   #     k = Klass.new
   #     k.send :hello, "gentle", "readers"   #=> "Hello gentle readers"
-  # 
+  #
   def __send__: (String | Symbol arg0, *untyped args) -> untyped
 
   # Equality --- At the `Object` level, `==` returns `true` only if `obj` and
   # `other` are the same object. Typically, this method is overridden in
   # descendant classes to provide class-specific meaning.
-  # 
+  #
   # Unlike `==`, the `equal?` method should never be overridden by subclasses as
   # it is used to determine object identity (that is, `a.equal?(b)` if and only if
   # `a` is the same object as `b`):
-  # 
+  #
   #     obj = "a"
   #     other = obj.dup
-  # 
+  #
   #     obj == other      #=> true
   #     obj.equal? other  #=> false
   #     obj.equal? obj    #=> true
-  # 
+  #
   # The `eql?` method returns `true` if `obj` and `other` refer to the same hash
   # key.  This is used by Hash to test members for equality.  For objects of class
   # `Object`, `eql?` is synonymous with `==`.  Subclasses normally continue this
   # tradition by aliasing `eql?` to their overridden `==` method, but there are
   # exceptions.  `Numeric` types, for example, perform type conversion across
   # `==`, but not across `eql?`, so:
-  # 
+  #
   #     1 == 1.0     #=> true
   #     1.eql? 1.0   #=> false
-  # 
+  #
   def equal?: (untyped other) -> bool
 
   # Evaluates a string containing Ruby source code, or the given block, within the
   # context of the receiver (*obj*). In order to set the context, the variable
   # `self` is set to *obj* while the code is executing, giving the code access to
   # *obj*'s instance variables and private methods.
-  # 
+  #
   # When `instance_eval` is given a block, *obj* is also passed in as the block's
   # only argument.
-  # 
+  #
   # When `instance_eval` is given a `String`, the optional second and third
   # parameters supply a filename and starting line number that are used when
   # reporting compilation errors.
-  # 
+  #
   #     class KlassWithSecret
   #       def initialize
   #         @secret = 99
@@ -165,7 +165,7 @@ class BasicObject
   #     k.instance_eval { @secret }          #=> 99
   #     k.instance_eval { the_secret }       #=> "Ssssh! The secret is 99."
   #     k.instance_eval {|obj| obj == self } #=> true
-  # 
+  #
   def instance_eval: (String, ?String filename, ?Integer lineno) -> untyped
                    | [U] () { (self) -> U } -> U
 
@@ -173,7 +173,7 @@ class BasicObject
   # to set the context, the variable `self` is set to *obj* while the code is
   # executing, giving the code access to *obj*'s instance variables.  Arguments
   # are passed as block parameters.
-  # 
+  #
   #     class KlassWithSecret
   #       def initialize
   #         @secret = 99
@@ -181,11 +181,11 @@ class BasicObject
   #     end
   #     k = KlassWithSecret.new
   #     k.instance_exec(5) {|x| @secret+x }   #=> 104
-  # 
+  #
   def instance_exec: [U, V] (*V args) { (*V args) -> U } -> U
 
   # Not documented
-  # 
+  #
   def initialize: () -> void
 
   private
@@ -199,7 +199,7 @@ class BasicObject
   # method. The example below creates a class `Roman`, which responds to methods
   # with names consisting of roman numerals, returning the corresponding integer
   # values.
-  # 
+  #
   #     class Roman
   #       def roman_to_int(str)
   #         # ...
@@ -209,16 +209,16 @@ class BasicObject
   #         roman_to_int(str)
   #       end
   #     end
-  # 
+  #
   #     r = Roman.new
   #     r.iv      #=> 4
   #     r.xxiii   #=> 23
   #     r.mm      #=> 2000
-  # 
+  #
   def method_missing: (Symbol, *untyped) -> untyped
 
   # Invoked as a callback whenever a singleton method is added to the receiver.
-  # 
+  #
   #     module Chatty
   #       def Chatty.singleton_method_added(id)
   #         puts "Adding #{id.id2name}"
@@ -227,18 +227,18 @@ class BasicObject
   #       def two()          end
   #       def Chatty.three() end
   #     end
-  # 
+  #
   # *produces:*
-  # 
+  #
   #     Adding singleton_method_added
   #     Adding one
   #     Adding three
-  # 
+  #
   def singleton_method_added: (Symbol) -> void
 
   # Invoked as a callback whenever a singleton method is removed from the
   # receiver.
-  # 
+  #
   #     module Chatty
   #       def Chatty.singleton_method_removed(id)
   #         puts "Removing #{id.id2name}"
@@ -251,17 +251,17 @@ class BasicObject
   #         remove_method :one
   #       end
   #     end
-  # 
+  #
   # *produces:*
-  # 
+  #
   #     Removing three
   #     Removing one
-  # 
+  #
   def singleton_method_removed: (Symbol) -> void
 
   # Invoked as a callback whenever a singleton method is undefined in the
   # receiver.
-  # 
+  #
   #     module Chatty
   #       def Chatty.singleton_method_undefined(id)
   #         puts "Undefining #{id.id2name}"
@@ -271,10 +271,10 @@ class BasicObject
   #          undef_method(:one)
   #       end
   #     end
-  # 
+  #
   # *produces:*
-  # 
+  #
   #     Undefining one
-  # 
+  #
   def singleton_method_undefined: (Symbol) -> void
 end