rbs 4.1.0.pre.2 → 4.1.0

data/lib/rbs/prototype/rbi.rb

@@ -9,10 +9,22 @@ module RBS
       attr_reader :modules
       attr_reader :last_sig
 
+      class Context
+        attr_accessor :singleton
+        attr_accessor :visibility
+
+        def initialize(singleton:, visibility:)
+          @singleton = singleton
+          @visibility = visibility
+        end
+      end
+
       def initialize
         @decls = []
 
         @modules = []
+        @contexts = []
+        @emitted_visibility = {}
       end
 
       def parse(string)
@@ -20,19 +32,17 @@ module RBS
         process RubyVM::AbstractSyntaxTree.parse(string), comments: comments
       end
 
-      def nested_name(name)
-        (current_namespace + const_to_name(name).to_namespace).to_type_name.relative!
-      end
-
-      def current_namespace
-        modules.inject(Namespace.empty) do |parent, mod|
-          parent + mod.name.to_namespace
+      def append_decl(decl)
+        if mod = current_module
+          mod.members << decl
+        else
+          decls << decl
         end
       end
 
       def push_class(name, super_class, comment:)
         class_decl = AST::Declarations::Class.new(
-          name: nested_name(name),
+          name: const_to_name(name),
           super_class: super_class && AST::Declarations::Class::Super.new(name: const_to_name(super_class), args: [], location: nil),
           type_params: [],
           members: [],
@@ -41,17 +51,20 @@ module RBS
           comment: comment
         )
 
+        append_decl class_decl
         modules << class_decl
-        decls << class_decl
+        @contexts << Context.new(singleton: false, visibility: :public)
+        @emitted_visibility[class_decl.object_id] = :public
 
         yield
       ensure
+        @contexts.pop
         modules.pop
       end
 
       def push_module(name, comment:)
         module_decl = AST::Declarations::Module.new(
-          name: nested_name(name),
+          name: const_to_name(name),
           type_params: [],
           members: [],
           annotations: [],
@@ -60,11 +73,14 @@ module RBS
           comment: comment
         )
 
+        append_decl module_decl
         modules << module_decl
-        decls << module_decl
+        @contexts << Context.new(singleton: false, visibility: :public)
+        @emitted_visibility[module_decl.object_id] = :public
 
         yield
       ensure
+        @contexts.pop
         modules.pop
       end
 
@@ -76,6 +92,47 @@ module RBS
         current_module or raise
       end
 
+      def current_context
+        @contexts.last
+      end
+
+      def current_context!
+        current_context or raise
+      end
+
+      # Visibility of a member, given as `private def ...` in RBS
+      #
+      # Returns `nil` for members in a visibility _section_, which `sync_visibility` emits instead.
+      def member_visibility(context)
+        # RBS visibility sections don't apply to singleton members, so they need their own visibility.
+        if context.singleton && context.visibility != :public
+          :private
+        end
+      end
+
+      def sync_visibility(visibility)
+        # Visibility sections don't apply to singleton members in RBS.
+        return if current_context!.singleton
+
+        # RBS has no protected visibility. Private is the conservative fallback.
+        visibility = :private if visibility == :protected
+
+        mod = current_module!
+        return if @emitted_visibility[mod.object_id] == visibility
+
+        member = case visibility
+                 when :public
+                   AST::Members::Public.new(location: nil)
+                 when :private
+                   AST::Members::Private.new(location: nil)
+                 else
+                   raise "Unexpected visibility: #{visibility}"
+                 end
+
+        mod.members << member
+        @emitted_visibility[mod.object_id] = visibility
+      end
+
       def push_sig(node)
         if last_sig = @last_sig
           last_sig << node
@@ -107,6 +164,15 @@ module RBS
           push_module node.children[0], comment: comment do
             process node.children[1], outer: outer + [node], comments: comments
           end
+        when :SCLASS
+          if node.children[0].type == :SELF
+            @contexts << Context.new(singleton: true, visibility: :public)
+            begin
+              process node.children[1], outer: outer + [node], comments: comments
+            ensure
+              @contexts.pop
+            end
+          end
         when :FCALL
           case node.children[0]
           when :include
@@ -125,9 +191,9 @@ module RBS
             end
           when :extend
             each_arg node.children[1] do |arg|
-              if arg.type == :CONST || arg.type == :COLON2
+              if arg.type == :CONST || arg.type == :COLON2 || arg.type == :COLON3
                 name = const_to_name(arg)
-                unless name.to_s == "T::Generic" || name.to_s == "T::Sig"
+                unless ["T::Generic", "T::Helpers", "T::Sig"].include?(name.to_s.delete_prefix("::"))
                   member = AST::Members::Extend.new(
                     name: name,
                     args: [],
@@ -142,6 +208,10 @@ module RBS
           when :sig
             out = outer.last or raise
             push_sig out.children.last.children.last
+          when :attr_reader, :attr_writer, :attr_accessor
+            process_attribute node, comments: comments
+          when :private, :protected, :public
+            process_visibility node, outer: outer, comments: comments
           when :alias_method
             new, old = each_arg(node.children[1]).map {|x| x.children[0] }
             current_module!.members << AST::Members::Alias.new(
@@ -149,10 +219,15 @@ module RBS
               old_name: old,
               location: nil,
               annotations: [],
-              kind: :instance,
+              kind: current_context!.singleton ? :singleton : :instance,
               comment: nil
             )
           end
+        when :VCALL
+          case node.children[0]
+          when :private, :protected, :public
+            current_context!.visibility = node.children[0]
+          end
         when :DEFS
           sigs = pop_sig
 
@@ -178,6 +253,8 @@ module RBS
           sigs = pop_sig
 
           if sigs
+            context = current_context!
+            sync_visibility(context.visibility)
             comment = join_comments(sigs, comments)
 
             args = node.children[1]
@@ -188,10 +265,10 @@ module RBS
               location: nil,
               annotations: [],
               overloads: types.map {|type| AST::Members::MethodDefinition::Overload.new(annotations: [], method_type: type) },
-              kind: :instance,
+              kind: context.singleton ? :singleton : :instance,
               comment: comment,
               overloading: false,
-              visibility: nil
+              visibility: member_visibility(context)
             )
           end
 
@@ -222,11 +299,7 @@ module RBS
             end
           else
             name = node.children[0].yield_self do |n|
-              if n.is_a?(Symbol)
-                TypeName.new(namespace: current_namespace, name: n)
-              else
-                const_to_name(n)
-              end
+              n.is_a?(Symbol) ? TypeName.new(namespace: Namespace.empty, name: n) : const_to_name(n)
             end
             value_node = node.children.last
             type = if value_node && value_node.type == :CALL && value_node.children[1] == :let
@@ -235,7 +308,7 @@ module RBS
                    else
                      Types::Bases::Any.new(location: nil)
                    end
-            decls << AST::Declarations::Constant.new(
+            append_decl AST::Declarations::Constant.new(
               name: name,
               type: type,
               location: nil,
@@ -244,12 +317,13 @@ module RBS
             )
           end
         when :ALIAS
+          sync_visibility(current_context!.visibility)
           current_module!.members << AST::Members::Alias.new(
             new_name: node.children[0].children[0],
             old_name: node.children[1].children[0],
             location: nil,
             annotations: [],
-            kind: :instance,
+            kind: current_context!.singleton ? :singleton : :instance,
             comment: nil
           )
         else
@@ -259,6 +333,93 @@ module RBS
         end
       end
 
+      def process_visibility(node, outer:, comments:)
+        visibility = node.children[0]
+        args = each_arg(node.children[1]).to_a
+        context = current_context!
+
+        if args.empty?
+          context.visibility = visibility
+        else
+          previous_visibility = context.visibility
+          context.visibility = visibility
+
+          begin
+            args.each do |arg|
+              if arg.type == :DEFN || arg.type == :DEFS
+                process arg, outer: outer + [node], comments: comments
+              end
+            end
+          ensure
+            context.visibility = previous_visibility
+          end
+        end
+      end
+
+      def process_attribute(node, comments:)
+        sigs = pop_sig
+        kind = node.children[0]
+        context = current_context!
+        sync_visibility(context.visibility)
+
+        type = attribute_type(kind, sigs)
+        comment = join_comments(sigs, comments) if sigs
+        member_class = case kind
+                       when :attr_reader
+                         AST::Members::AttrReader
+                       when :attr_writer
+                         AST::Members::AttrWriter
+                       when :attr_accessor
+                         AST::Members::AttrAccessor
+                       else
+                         raise "Unexpected attribute kind: #{kind}"
+                       end
+
+        each_arg node.children[1] do |arg|
+          if name = symbol_literal_node?(arg)
+            current_module!.members << member_class.new(
+              name: name,
+              type: type,
+              ivar_name: nil,
+              kind: context.singleton ? :singleton : :instance,
+              annotations: [],
+              location: nil,
+              comment: comment,
+              visibility: member_visibility(context)
+            )
+          end
+        end
+      end
+
+      def attribute_type(kind, sigs)
+        any = Types::Bases::Any.new(location: nil)
+        return any unless sigs
+
+        method_types = sigs.filter_map do |sig|
+          method_type(nil, sig, variables: current_module!.type_params, overloads: sigs.size)
+        end
+        function = method_types.last&.type
+        return any unless function.is_a?(Types::Function)
+
+        parameter_type = function.required_positionals.first&.type
+        return_type = function.return_type
+
+        case kind
+        when :attr_reader
+          return_type
+        when :attr_writer
+          parameter_type || return_type
+        when :attr_accessor
+          if return_type.is_a?(Types::Bases::Any) || return_type.is_a?(Types::Bases::Void)
+            parameter_type || any
+          else
+            return_type
+          end
+        else
+          any
+        end
+      end
+
       def method_type(args_node, type_node, variables:, overloads:)
         if type_node
           if type_node.type == :CALL
@@ -463,8 +624,10 @@ module RBS
         case
         when type.is_a?(Types::ClassInstance) && type.name.name == BuiltinNames::BasicObject.name.name
           Types::Bases::Any.new(location: nil)
-        when type.is_a?(Types::ClassInstance) && type.name.to_s == "T::Boolean"
+        when type.is_a?(Types::ClassInstance) && type.name.to_s.delete_prefix("::") == "T::Boolean"
           Types::Bases::Bool.new(location: nil)
+        when type.is_a?(Types::ClassInstance) && type.name.to_s.delete_prefix("::") == "T::Class"
+          Types::Bases::Any.new(location: nil)
         else
           type
         end
@@ -482,6 +645,11 @@ module RBS
           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
+          receiver = type_node.children[0]
+          if [:CONST, :COLON2, :COLON3].include?(receiver.type) && const_to_name(receiver).to_s.delete_prefix("::") == "T::Class"
+            return Types::Bases::Any.new(location: nil)
+          end
+
           type = type_of(type_node.children[0], variables: variables)
           type.is_a?(Types::ClassInstance) or raise
 
@@ -559,7 +727,7 @@ module RBS
 
           type_name = TypeName.new(name: node.children[1], namespace: namespace)
 
-          case type_name.to_s
+          case type_name.to_s.delete_prefix("::")
           when "T::Array"
             BuiltinNames::Array.name
           when "T::Hash"

data/lib/rbs/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RBS
-  VERSION = "4.1.0.pre.2"
+  VERSION = "4.1.0"
 end

data/lib/rbs/wasm/runtime.rb

@@ -10,21 +10,12 @@ module RBS
     # source string into the module's linear memory, runs the parser, and returns
     # the serialized result for RBS::WASM::Deserializer to rebuild.
     #
-    # Chicory is a pure-Java runtime, so there is no native dependency: only the
-    # `.wasm` and the Chicory jars need to ship with the gem.
+    # Chicory is a pure-Java runtime, so there is no native dependency. The
+    # `.wasm` ships in the gem; the Chicory jars are fetched from Maven by
+    # jar-dependencies (see lib/rbs_jars.rb and rbs.gemspec).
     class Runtime
       include MonitorMixin
 
-      # The Chicory jars the runtime needs at load time.
-      # Jars Chicory needs to load and run the module.
-      JARS = %w[wasm runtime log wasi].freeze
-
-      # Jars for Chicory's ahead-of-time compiler (wasm -> JVM bytecode), which
-      # runs the parser ~8x faster than the interpreter. Optional: the runtime
-      # falls back to the interpreter when they are absent. asm* are the ow2 ASM
-      # libraries the compiler depends on.
-      OPTIONAL_JARS = %w[compiler asm asm-tree asm-util asm-commons asm-analysis].freeze
-
       class << self
         def instance
           @instance ||= new
@@ -33,15 +24,14 @@ module RBS
         def wasm_path
           ENV["RBS_WASM_PARSER"] || File.expand_path("rbs_parser.wasm", __dir__)
         end
-
-        def jars_dir
-          ENV["RBS_WASM_JARS"] || File.expand_path("jars", __dir__)
-        end
       end
 
       def initialize
         super()
-        load_jars
+        # rbs_jars.rb require_jars the Chicory/ASM jars from the local Maven
+        # repository (~/.m2), where jar-dependencies puts them at gem install (or
+        # `rake wasm:install_jars` when running from source).
+        require "rbs_jars"
         @wasm = build_instance
         @memory = @wasm.memory
         @alloc = @wasm.export("rbs_wasm_alloc")
@@ -201,17 +191,6 @@ module RBS
         nil
       end
 
-      def load_jars
-        JARS.each { |name| require jar_path(name) }
-        OPTIONAL_JARS.each do |name|
-          path = jar_path(name)
-          require path if File.exist?(path)
-        end
-      end
-
-      def jar_path(name)
-        File.join(self.class.jars_dir, "#{name}.jar")
-      end
     end
   end
 end

data/lib/rbs_jars.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+# This is the file jar-dependencies generates from the `jar` requirements in
+# rbs.gemspec, kept with hand edits:
+#   1. the `com.dylibso.chicory:runtime` require_jar line is corrected -- the
+#      generator mangles that artifact id to `jar` (it collides with a Maven
+#      scope keyword), which breaks loading;
+#   2. the "# this is a generated file" marker is dropped so jar-dependencies
+#      does not regenerate (and re-break) this file at gem install;
+#   3. a frozen_string_literal magic comment is added (rubocop).
+# `rake wasm:install_jars` downloads the jars into ~/.m2; to refresh the list
+# after a version bump, regenerate the file and re-apply these edits.
+begin
+  require 'jar_dependencies'
+rescue LoadError
+  require 'com/dylibso/chicory/compiler/1.7.5/compiler-1.7.5.jar'
+  require 'com/dylibso/chicory/runtime/1.7.5/runtime-1.7.5.jar'
+  require 'com/dylibso/chicory/wasm/1.7.5/wasm-1.7.5.jar'
+  require 'org/ow2/asm/asm/9.9.1/asm-9.9.1.jar'
+  require 'org/ow2/asm/asm-commons/9.9.1/asm-commons-9.9.1.jar'
+  require 'org/ow2/asm/asm-tree/9.9.1/asm-tree-9.9.1.jar'
+  require 'org/ow2/asm/asm-util/9.9.1/asm-util-9.9.1.jar'
+  require 'org/ow2/asm/asm-analysis/9.9.1/asm-analysis-9.9.1.jar'
+  require 'com/dylibso/chicory/wasi/1.7.5/wasi-1.7.5.jar'
+  require 'com/dylibso/chicory/log/1.7.5/log-1.7.5.jar'
+end
+
+if defined? Jars
+  require_jar 'com.dylibso.chicory', 'compiler', '1.7.5'
+  require_jar 'com.dylibso.chicory', 'runtime', '1.7.5'
+  require_jar 'com.dylibso.chicory', 'wasm', '1.7.5'
+  require_jar 'org.ow2.asm', 'asm', '9.9.1'
+  require_jar 'org.ow2.asm', 'asm-commons', '9.9.1'
+  require_jar 'org.ow2.asm', 'asm-tree', '9.9.1'
+  require_jar 'org.ow2.asm', 'asm-util', '9.9.1'
+  require_jar 'org.ow2.asm', 'asm-analysis', '9.9.1'
+  require_jar 'com.dylibso.chicory', 'wasi', '1.7.5'
+  require_jar 'com.dylibso.chicory', 'log', '1.7.5'
+end

data/lib/rdoc_plugin/parser.rb

@@ -14,6 +14,11 @@ module RBS
       end
 
       def scan
+        Kernel.warn(
+          "The RBS RDoc parser plugin is deprecated and will be removed from RBS. " \
+          "RDoc 8.0 provides RBS parsing directly."
+        )
+
         _, _, decls = ::RBS::Parser.parse_signature(@content)
         decls.each do |decl|
           parse_member(decl: decl, context: @top_level)

data/rbs.gemspec

@@ -38,8 +38,10 @@ Gem::Specification.new do |spec|
 
   # JRuby cannot load the MRI C extension. On JRuby (and in the `java` platform
   # gem, built with RBS_PLATFORM=java) RBS runs the WebAssembly-backed parser, so
-  # ship the prebuilt parser and the Chicory jars (assembled by
-  # `rake wasm:jruby_setup`) and skip the C extension.
+  # ship the prebuilt parser (built by `rake wasm:build`) and skip the C
+  # extension. The Chicory/ASM jars the runtime needs are NOT shipped in the gem:
+  # they are declared as `jar-dependencies` requirements below and fetched from
+  # Maven Central at install time (see lib/rbs/wasm/jars.rb).
   building_java_gem = ENV["RBS_PLATFORM"] == "java"
   on_jruby = defined?(RUBY_ENGINE) && RUBY_ENGINE == "jruby"
 
@@ -47,9 +49,20 @@ Gem::Specification.new do |spec|
     # Only stamp the platform when building the release gem; leave it unset for
     # local development on JRuby so it still matches a `ruby` platform lockfile.
     spec.platform = "java" if building_java_gem
+    # rbs_parser.wasm is a build artifact (not tracked in git), so add it
+    # explicitly. lib/rbs_jars.rb is committed, so git ls-files already has it.
     spec.files += Dir.chdir(File.expand_path('..', __FILE__)) do
-      Dir.glob("lib/rbs/wasm/rbs_parser.wasm") + Dir.glob("lib/rbs/wasm/jars/*.jar")
+      Dir.glob("lib/rbs/wasm/rbs_parser.wasm")
     end
+
+    # jar-dependencies (bundled with JRuby) downloads these jars from Maven when
+    # the gem is installed, keeping the gem small and avoiding conflicting copies.
+    # Only the top-level artifacts are declared; Maven resolves the rest (runtime,
+    # wasm, asm, ...) transitively. lib/rbs_jars.rb require_jars the full resolved
+    # set at load time.
+    spec.add_dependency "jar-dependencies", ">= 0.1.7"
+    spec.requirements << "jar com.dylibso.chicory:compiler, 1.7.5"
+    spec.requirements << "jar com.dylibso.chicory:wasi, 1.7.5"
   else
     spec.extensions = %w{ext/rbs_extension/extconf.rb}
   end

data/sig/prototype/rbi.rbs

@@ -2,7 +2,17 @@ module RBS
   module Prototype
     class RBI
       include Helpers
-      
+
+      type visibility = :private | :protected | :public
+
+      class Context
+        attr_accessor singleton: bool
+
+        attr_accessor visibility: visibility
+
+        def initialize: (singleton: bool, visibility: visibility) -> void
+      end
+
       attr_reader decls: Array[AST::Declarations::t]
 
       type module_decl = AST::Declarations::Class | AST::Declarations::Module
@@ -13,13 +23,15 @@ module RBS
       # Last subsequent `sig` calls
       attr_reader last_sig: Array[RubyVM::AbstractSyntaxTree::Node]?
 
+      @contexts: Array[Context]
+
+      @emitted_visibility: Hash[Integer, visibility]
+
       def initialize: () -> void
 
       def parse: (String) -> void
 
-      def nested_name: (RubyVM::AbstractSyntaxTree::Node name) -> TypeName
-
-      def current_namespace: () -> Namespace
+      def append_decl: (AST::Declarations::t decl) -> void
 
       def push_class: (
         RubyVM::AbstractSyntaxTree::Node name,
@@ -35,6 +47,17 @@ module RBS
       # The inner most module/class definition, raises on toplevel
       def current_module!: () -> module_decl
 
+      def current_context: () -> Context?
+
+      def current_context!: () -> Context
+
+      # Visibility of a member, given as `private def ...` in RBS
+      #
+      # Returns `nil` for members in a visibility _section_, which `sync_visibility` emits instead.
+      def member_visibility: (Context) -> AST::Members::visibility?
+
+      def sync_visibility: (visibility) -> void
+
       # Put a `sig` call to current list.
       def push_sig: (RubyVM::AbstractSyntaxTree::Node node) -> void
 
@@ -45,6 +68,12 @@ module RBS
 
       def process: (RubyVM::AbstractSyntaxTree::Node node, comments: Hash[Integer, AST::Comment], ?outer: Array[RubyVM::AbstractSyntaxTree::Node]) -> void
 
+      def process_visibility: (RubyVM::AbstractSyntaxTree::Node node, outer: Array[RubyVM::AbstractSyntaxTree::Node], comments: Hash[Integer, AST::Comment]) -> void
+
+      def process_attribute: (RubyVM::AbstractSyntaxTree::Node node, comments: Hash[Integer, AST::Comment]) -> void
+
+      def attribute_type: (:attr_reader | :attr_writer | :attr_accessor kind, Array[RubyVM::AbstractSyntaxTree::Node]? sigs) -> Types::t
+
       def method_type: (RubyVM::AbstractSyntaxTree::Node? args_node, RubyVM::AbstractSyntaxTree::Node? type_node, variables: Array[AST::TypeParam], overloads: Integer) -> MethodType?
 
       def parse_params: (RubyVM::AbstractSyntaxTree::Node args_node, RubyVM::AbstractSyntaxTree::Node args, MethodType method_type, variables: Array[AST::TypeParam], overloads: Integer) -> MethodType