rbs 3.1.3 → 3.2.0.pre.1

data/docs/syntax.md

@@ -51,7 +51,7 @@ _proc_ ::= _parameters?_ _self-type-binding?_ _block?_ `->` _type_
 
 Class instance type denotes _an instance of a class_.
 
-```
+```rbs
 Integer                      # Instance of Integer class
 ::Integer                    # Instance of ::Integer class
 Hash[Symbol, String]         # Instance of Hash class with type application of Symbol and String
@@ -61,7 +61,7 @@ Hash[Symbol, String]         # Instance of Hash class with type application of S
 
 Interface type denotes _type of a value which can be a subtype of the interface_.
 
-```
+```rbs
 _ToS                          # _ToS interface
 ::MyApp::_Each[String]        # Interface name with namespace and type application
 ```
@@ -72,7 +72,7 @@ Alias type denotes an alias declared with _alias declaration_.
 
 The name of type aliases starts with lowercase `[a-z]`.
 
-```
+```rbs
 name
 ::JSON::t                    # Alias name with namespace
 list[Integer]                # Type alias can be generic
@@ -82,7 +82,7 @@ list[Integer]                # Type alias can be generic
 
 Class singleton type denotes _the type of a singleton object of a class_.
 
-```
+```rbs
 singleton(String)
 singleton(::Hash)            # Class singleton type cannot be parametrized.
 ```
@@ -91,7 +91,7 @@ singleton(::Hash)            # Class singleton type cannot be parametrized.
 
 Literal type denotes _a type with only one value of the literal_.
 
-```
+```rbs
 123                         # Integer
 "hello world"               # A string
 :to_s                       # A symbol
@@ -102,7 +102,7 @@ true                        # true or false
 
 Union type denotes _a type of one of the given types_.
 
-```
+```rbs
 Integer | String           # Integer or String
 Array[Integer | String]    # Array of Integer or String
 ```
@@ -111,7 +111,7 @@ Array[Integer | String]    # Array of Integer or String
 
 Intersection type denotes _a type of all of the given types_.
 
-```
+```rbs
 _Reader & _Writer           # _Reader and _Writer
 ```
 
@@ -121,7 +121,7 @@ Note that `&` has higher precedence than `|` that `A & B | C` is `(A & B) | C`.
 
 Optional type denotes _a type of value or nil_.
 
-```
+```rbs
 Integer?
 Array[Integer?]
 ```
@@ -130,7 +130,7 @@ Array[Integer?]
 
 Records are `Hash` objects, fixed set of keys, and heterogeneous.
 
-```
+```rbs
 { id: Integer, name: String }     # Hash object like `{ id: 31, name: String }`
 ```
 
@@ -138,7 +138,7 @@ Records are `Hash` objects, fixed set of keys, and heterogeneous.
 
 Tuples are `Array` objects, fixed size and heterogeneous.
 
-```
+```rbs
 [ ]                               # Empty like `[]`
 [String]                          # Single string like `["hi"]`
 [Integer, Integer]                # Pair of integers like `[1, 2]`
@@ -149,7 +149,7 @@ Tuples are `Array` objects, fixed size and heterogeneous.
 
 ### Type variable
 
-```
+```rbs
 U
 T
 S
@@ -159,7 +159,7 @@ Elem
 Type variables cannot be distinguished from _class instance types_.
 They are scoped in _class/module/interface/alias declaration_ or _generic method types_.
 
-```
+```rbs
 class Ref[T]              # Object is scoped in the class declaration.
   @value: T               # Type variable `T`
   def map: [X] { (T) -> X } -> Ref[X]   # X is a type variable scoped in the method type.
@@ -193,7 +193,7 @@ It is an alias of `top` type, and you can use `boolish` if we want to allow any
 
 We can see an example at the definition of `Enumerable#find`:
 
-```
+```rbs
 module Enumerable[Elem, Return]
   def find: () { (Elem) -> boolish } -> Elem?
 end
@@ -201,7 +201,7 @@ end
 
 We want to write something like:
 
-```
+```ruby
 array.find {|x| x && x.some_test? }               # The block will return (bool | nil)
 ```
 
@@ -218,7 +218,7 @@ They are all equivalent for the type system; they are all _top type_.
 
 Proc type denotes type of procedures, `Proc` instances.
 
-```
+```rbs
 ^(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`
 ```
@@ -266,7 +266,7 @@ Variable name can be used for documentation.
 
 #### Examples
 
-```
+```rbs
 # Two required positional `Integer` parameters, and returns `String`
 (Integer, Integer) -> String
 
@@ -359,7 +359,7 @@ _method-name_ ::= ...
 
 An instance variable definition consists of the name of an instance variable and its type.
 
-```
+```rbs
 @name: String
 @value: Hash[Symbol, Key]
 ```
@@ -370,7 +370,7 @@ 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 module function.
 
-```
+```rbs
 def to_s: () -> String                        # Defines a instance method
 def self.new: () -> AnObject                  # Defines singleton method
 def self?.sqrt: (Numeric) -> Numeric          # self? is for `module_function`s
@@ -380,7 +380,7 @@ def self?.sqrt: (Numeric) -> Numeric          # self? is for `module_function`s
 
 The method type can be connected with `|`s to define an overloaded method.
 
-```
+```rbs
 def +: (Float) -> Float
      | (Integer) -> Integer
      | (Numeric) -> Numeric
@@ -388,7 +388,7 @@ def +: (Float) -> Float
 
 Overloaded method can have `...` to overload an existing method. It is useful for monkey-patching.
 
-```
+```rbs
 def +: (Float) -> Float
 def +: (BigDecimal) -> BigDecimal
      | ...
@@ -396,14 +396,14 @@ def +: (BigDecimal) -> BigDecimal
 
 You need extra parentheses on return type to avoid ambiguity.
 
-```
+```rbs
 def +: (Float | Integer) -> (Float | Integer)
      | (Numeric) -> Numeric
 ```
 
 Adding `public` and `private` modifier changes the visibility of the method.
 
-```
+```rbs
 private def puts: (*untyped) -> void       # Defines private instance method
 
 public def self.puts: (*untyped) -> void   # Defines public singleton method
@@ -417,7 +417,7 @@ Attribute definitions help to define methods and instance variables based on the
 
 You can specify the name of instance variable using `(@some_name)` syntax and also omit the instance variable definition by specifying `()`.
 
-```
+```rbs
 # Defines `id` method and `@id` instance variable.
 attr_reader id: Integer
 # @id: Integer
@@ -436,7 +436,7 @@ attr_accessor people (): Array[Person]
 
 Attribute definitions can have the `public` and `private` modifiers like method definitions:
 
-```
+```rbs
 private attr_accessor id: Integer
 
 private attr_reader self.name: String
@@ -446,7 +446,7 @@ private attr_reader self.name: String
 
 You can define mixins between class and modules.
 
-```
+```rbs
 include Kernel
 include Enumerable[String, void]
 extend ActiveSupport::Concern
@@ -454,7 +454,7 @@ extend ActiveSupport::Concern
 
 You can also `include` or `extend` an interface.
 
-```
+```rbs
 include _Hashing
 extend _LikeString
 ```
@@ -465,7 +465,7 @@ This allows importing `def`s from the interface to help developer implementing a
 
 You can define an alias between methods.
 
-```
+```rbs
 def map: [X] () { (String) -> X } -> Array[X]
 alias collect map                                   # `#collect` has the same type with `map`
 ```
@@ -548,7 +548,7 @@ Class declaration can have type parameters and superclass. When you omit supercl
 
 Module declaration takes optional _self type_ parameter, which defines a constraint about a class when the module is mixed.
 
-```
+```rbs
 interface _Each[A, B]
   def each: { (A) -> void } -> B
 end
@@ -572,7 +572,7 @@ class Bar = Array
 
 The syntax defines a class and the definition is equivalent to the right-hand-side.
 
-```
+```rbs
 class Baz < Bar[String]    # Class alias can be inherited
   include Foo              # Module alias can be included
 end
@@ -590,7 +590,7 @@ end
 
 Interface declaration can have parameters but allows only a few of the members.
 
-```
+```rbs
 interface _Hashing
   def hash: () -> Integer
   def eql?: (untyped) -> bool
@@ -602,7 +602,7 @@ There are several limitations which are not described in the grammar.
 1. Interface cannot `include` modules
 2. Interface cannot have singleton method definitions
 
-```
+```rbs
 interface _Foo
   include Bar                  # Error: cannot include modules
   def self.new: () -> Foo      # Error: cannot include singleton method definitions
@@ -613,14 +613,14 @@ end
 
 You can declare an alias of types.
 
-```
+```rbs
 type subject = Attendee | Speaker
 type JSON::t = Integer | TrueClass | FalseClass | String | Hash[Symbol, t] | Array[t]
 ```
 
 Type alias can be generic like class, module, and interface.
 
-```
+```rbs
 type list[out T] = [T, list[T]] | nil
 ```
 
@@ -628,7 +628,7 @@ type list[out T] = [T, list[T]] | nil
 
 You can declare a constant.
 
-```
+```rbs
 Person::DefaultEmailAddress: String
 ```
 
@@ -636,13 +636,13 @@ Person::DefaultEmailAddress: String
 
 You can declare a global variable.
 
-```
+```rbs
 $LOAD_PATH: Array[String]
 ```
 
 ### Generics
 
-```md
+```markdown
 _module-type-parameter_ ::= _generics-unchecked_ _generics-variance_ _type-variable_ _generics-bound_
 
 _method-type-param_ ::= _type-variable_ _generics-bound_
@@ -677,7 +677,7 @@ For classes with type parameters, you may specify if they are "invariant" (defau
 
 For example, an `Array` of `String` can almost be considered to be an `Array` of `Object`, but not the reverse, so we can think of:
 
-```
+```rbs
 # The `T` type parameter is covariant.
 class Array[out T]
   # etc.
@@ -732,7 +732,7 @@ The upper bound must be one of a class instance type, interface type, or class s
 
 Directives are placed at the top of a file and provides per-file-basis features.
 
-```
+```markdown
 _use-directive_ ::= `use` _use-clauses_
 
 _use-clauses_ ::= _use-clause_ `,` ... `,` _use-clause_
@@ -745,7 +745,7 @@ _use-clause_ ::= _type-name_                           # Single use clause
 The *use directive* defines relative type names that is an alias of other type names.
 We can use the simple type names if it is declared with *use*.
 
-```
+```rbs
 use RBS::Namespace        # => Defines `Namespace`
 use RBS::TypeName as TN   # => Defines `TN`
 use RBS::AST::*           # => Defines modules under `::RBS::AST::` namespace
@@ -755,7 +755,7 @@ use RBS::AST::*           # => Defines modules under `::RBS::AST::` namespace
 
 You can write single line comments. Comments must be on their own line. Comments can lead with whitespace.
 
-```
+```rbs
 # This if interface Foo
 # Usage of Foo is bar
 interface _Foo

data/lib/rbs/cli.rb

@@ -645,6 +645,7 @@ EOU
         relative_libs = []
         merge = false
         owners_included = []
+        outline = false
 
         OptionParser.new do |opts|
           opts.banner = <<EOU
@@ -657,7 +658,7 @@ Examples:
 
   $ rbs prototype runtime String
   $ rbs prototype runtime --require set Set
-  $ rbs prototype runtime -R lib/rbs RBS::*
+  $ rbs prototype runtime -R lib/rbs RBS RBS::*
 
 Options:
 EOU
@@ -673,6 +674,9 @@ EOU
           opts.on("--method-owner CLASS", "Generate method prototypes if the owner of the method is [CLASS]") do |klass|
             owners_included << klass
           end
+          opts.on("--outline", "Generates only module/class/constant declaration (no method definition)") do
+            outline = true
+          end
         end.parse!(args)
 
         loader = options.loader()
@@ -686,7 +690,10 @@ EOU
           eval("require_relative(lib)", binding, "rbs")
         end
 
-        decls = Prototype::Runtime.new(patterns: args, env: env, merge: merge, owners_included: owners_included).decls
+        runtime = Prototype::Runtime.new(patterns: args, env: env, merge: merge, owners_included: owners_included)
+        runtime.outline = outline
+
+        decls = runtime.decls
 
         writer = Writer.new(out: stdout)
         writer.write decls
@@ -961,7 +968,7 @@ Options:
           Parser.public_send(parse_method, buf, require_eof: true)
         end
       rescue RBS::ParsingError => ex
-        stdout.puts ex.message
+        stdout.print ex.detailed_message(highlight: true)
         syntax_error = true
       end
 
@@ -1241,7 +1248,11 @@ EOB
           w.write(subtracted)
 
           if write_to_file
-            rbs_path.write(io.string)
+            if io.string.empty?
+              rbs_path.delete
+            else
+              rbs_path.write(io.string)
+            end
           else
             stdout.puts(io.string)
           end

data/lib/rbs/collection/installer.rb

@@ -14,7 +14,10 @@ module RBS
       def install_from_lockfile
         install_to = lockfile.fullpath
         install_to.mkpath
-        lockfile.gems.each_value do |gem|
+        selected = lockfile.gems.select do |name, gem|
+          gem[:source].has?(name, gem[:version])
+        end
+        selected.each_value do |gem|
           gem[:source].install(
             dest: install_to,
             name: gem[:name],
@@ -22,7 +25,7 @@ module RBS
             stdout: stdout
           )
         end
-        stdout.puts "It's done! #{lockfile.gems.size} gems' RBSs now installed."
+        stdout.puts "It's done! #{selected.size} gems' RBSs now installed."
       end
     end
   end

data/lib/rbs/collection/sources/stdlib.rb

@@ -27,7 +27,11 @@ module RBS
         end
 
         def manifest_of(name, version)
-          manifest_path = (lookup(name, version) or raise).join('manifest.yaml')
+          unless path = lookup(name, version)
+            RBS.logger.warn "`#{name}` is specified in rbs_collection.lock.yaml. But it is not found in #{REPO.dirs.join(",")}"
+            return
+          end
+          manifest_path = path.join('manifest.yaml')
           YAML.safe_load(manifest_path.read) if manifest_path.exist?
         end
 

data/lib/rbs/errors.rb

@@ -22,7 +22,14 @@ module RBS
 
   module DetailedMessageable
     def detailed_message(highlight: false, **)
-      msg = super
+      msg = if Exception.method_defined?(:detailed_message)
+        super
+      else
+        # Failback to `#message` in Ruby 3.1 or earlier
+        "#{message} (#{self.class.name})"
+      end
+
+      return msg unless location
 
       # Support only one line
       return msg unless location.start_line == location.end_line

data/lib/rbs/file_finder.rb

@@ -5,7 +5,7 @@ module RBS
     module_function
 
     def self.each_file(path, immediate:, skip_hidden:, &block)
-      return enum_for(__method__, path, immediate: immediate, skip_hidden: skip_hidden) unless block
+      return enum_for((__method__ or raise), path, immediate: immediate, skip_hidden: skip_hidden) unless block
 
       case
       when path.file?

data/lib/rbs/prototype/rb.rb

@@ -5,11 +5,11 @@ module RBS
     class RB
       include Helpers
 
-      Context = _ = Struct.new(:module_function, :singleton, :namespace, keyword_init: true) do
+      Context = _ = Struct.new(:module_function, :singleton, :namespace, :in_def, keyword_init: true) do
         # @implements Context
 
         def self.initial(namespace: Namespace.root)
-          self.new(module_function: false, singleton: false, namespace: namespace)
+          self.new(module_function: false, singleton: false, namespace: namespace, in_def: false)
         end
 
         def method_kind
@@ -29,6 +29,14 @@ module RBS
             :instance
           end
         end
+
+        def enter_namespace(namespace)
+          Context.initial(namespace: self.namespace + namespace)
+        end
+
+        def update(module_function: self.module_function, singleton: self.singleton, in_def: self.in_def)
+          Context.new(module_function: module_function, singleton: singleton, namespace: namespace, in_def: in_def)
+        end
       end
 
       attr_reader :source_decls
@@ -121,11 +129,12 @@ module RBS
 
           decls.push kls
 
-          new_ctx = Context.initial(namespace: context.namespace + kls.name.to_namespace)
+          new_ctx = context.enter_namespace(kls.name.to_namespace)
           each_node class_body do |child|
             process child, decls: kls.members, comments: comments, context: new_ctx
           end
           remove_unnecessary_accessibility_methods! kls.members
+          sort_members! kls.members
 
         when :MODULE
           module_name, *module_body = node.children
@@ -142,11 +151,12 @@ module RBS
 
           decls.push mod
 
-          new_ctx = Context.initial(namespace: context.namespace + mod.name.to_namespace)
+          new_ctx = context.enter_namespace(mod.name.to_namespace)
           each_node module_body do |child|
             process child, decls: mod.members, comments: comments, context: new_ctx
           end
           remove_unnecessary_accessibility_methods! mod.members
+          sort_members! mod.members
 
         when :SCLASS
           this, body = node.children
@@ -195,6 +205,11 @@ module RBS
 
           decls.push member unless decls.include?(member)
 
+          new_ctx = context.update(singleton: kind == :singleton, in_def: true)
+          each_node def_body.children do |child|
+            process child, decls: decls, comments: comments, context: new_ctx
+          end
+
         when :ALIAS
           new_name, old_name = node.children.map { |c| literal_to_symbol(c) }
           member = AST::Members::Alias.new(
@@ -306,7 +321,7 @@ module RBS
             if args.empty?
               context.module_function = true
             else
-              module_func_context = context.dup.tap { |ctx| ctx.module_function = true }
+              module_func_context = context.update(module_function: true)
               args.each do |arg|
                 if arg && (name = literal_to_symbol(arg))
                   if (i, defn = find_def_index_by_name(decls, name))
@@ -377,6 +392,39 @@ module RBS
             comment: comments[node.first_lineno - 1]
           )
 
+        when :IASGN
+          case [context.singleton, context.in_def]
+          when [true, true], [false, false]
+            member = AST::Members::ClassInstanceVariable.new(
+              name: node.children.first,
+              type: Types::Bases::Any.new(location: nil),
+              location: nil,
+              comment: comments[node.first_lineno - 1]
+            )
+          when [false, true]
+            member = AST::Members::InstanceVariable.new(
+              name: node.children.first,
+              type: Types::Bases::Any.new(location: nil),
+              location: nil,
+              comment: comments[node.first_lineno - 1]
+            )
+          when [true, false]
+            # The variable is for the singleton class of the class object.
+            # RBS does not have a way to represent it. So we ignore it.
+          else
+            raise 'unreachable'
+          end
+
+          decls.push member if member && !decls.include?(member)
+
+        when :CVASGN
+          member = AST::Members::ClassVariable.new(
+            name: node.children.first,
+            type: Types::Bases::Any.new(location: nil),
+            location: nil,
+            comment: comments[node.first_lineno - 1]
+          )
+          decls.push member unless decls.include?(member)
         else
           process_children(node, decls: decls, comments: comments, context: context)
         end
@@ -413,7 +461,7 @@ module RBS
           when :SELF
             context.namespace.to_type_name
           when :CONST, :COLON2, :COLON3
-            const_to_name!(node)
+            const_to_name!(node) rescue nil
           end
         end
       end
@@ -743,6 +791,16 @@ module RBS
           ]
         end
       end
+
+      def sort_members!(decls)
+        i = 0
+        orders = {
+          AST::Members::ClassVariable => -3,
+          AST::Members::ClassInstanceVariable => -2,
+          AST::Members::InstanceVariable => -1,
+        }
+        decls.sort_by! { |decl| [orders.fetch(decl.class, 0), i += 1] }
+      end
     end
   end
 end

data/lib/rbs/prototype/rbi.rb

@@ -479,7 +479,7 @@ module RBS
           else
             Types::ClassInstance.new(name: const_to_name(type_node), args: [], location: nil)
           end
-        when type_node.type == :COLON2
+        when type_node.type == :COLON2 || type_node.type == :COLON3
           Types::ClassInstance.new(name: const_to_name(type_node), args: [], location: nil)
         when call_node?(type_node, name: :[], receiver: -> (_) { true })
           # The type_node represents a type application
@@ -553,11 +553,7 @@ module RBS
           TypeName.new(name: node.children[0], namespace: Namespace.empty)
         when :COLON2
           if node.children[0]
-            if node.children[0].type == :COLON3
-              namespace = Namespace.root
-            else
-              namespace = const_to_name(node.children[0]).to_namespace
-            end
+            namespace = const_to_name(node.children[0]).to_namespace
           else
             namespace = Namespace.empty
           end