rbs 4.1.0.pre.1 → 4.1.0

data/lib/rbs/namespace.rb

@@ -9,30 +9,65 @@ module RBS
       @absolute = absolute ? true : false
     end
 
+    # Process-wide flyweight cache. Two tries (one per `absolute` flag)
+    # keyed on path Symbols, with the cached Namespace stored under the
+    # `INTERN_LEAF` sentinel at each path's terminal node.
+    @intern_mutex = Mutex.new
+    @intern_trie_absolute = {}
+    @intern_trie_relative = {}
+    INTERN_LEAF = Module.new
+
+    # Returns a canonical `Namespace` instance for the given `path` /
+    # `absolute` pair. Repeated calls with structurally equal arguments
+    # return the same object, so callers can rely on `equal?` for fast
+    # equality. The path Array is duplicated and frozen on insert.
+    def self.[](path, absolute)
+      absolute = absolute ? true : false
+
+      # Lock-free fast path.
+      node = absolute ? @intern_trie_absolute : @intern_trie_relative
+      path.each do |sym|
+        node = node[sym]
+        break unless node
+      end
+      if node && (cached = node[INTERN_LEAF])
+        return cached
+      end
+
+      @intern_mutex.synchronize do
+        node = absolute ? @intern_trie_absolute : @intern_trie_relative
+        path.each { |sym| node = (node[sym] ||= {}) }
+        node[INTERN_LEAF] ||= begin
+          frozen_path = path.frozen? ? path : path.dup.freeze
+          new(path: frozen_path, absolute: absolute)
+        end
+      end
+    end
+
     def self.empty
-      @empty ||= new(path: [], absolute: false)
+      @empty ||= self[[], false]
     end
 
     def self.root
-      @root ||= new(path: [], absolute: true)
+      @root ||= self[[], true]
     end
 
     def +(other)
       if other.absolute?
         other
       else
-        self.class.new(path: path + other.path, absolute: absolute?)
+        Namespace[path + other.path, absolute?]
       end
     end
 
     def append(component)
-      self.class.new(path: path + [component], absolute: absolute?)
+      Namespace[path + [component], absolute?]
     end
 
     def parent
       @parent ||= begin
         raise "Parent with empty namespace" if empty?
-        self.class.new(path: path.take(path.size - 1), absolute: absolute?)
+        Namespace[path.take(path.size - 1), absolute?]
       end
     end
 
@@ -45,11 +80,11 @@ module RBS
     end
 
     def absolute!
-      self.class.new(path: path, absolute: true)
+      Namespace[path, true]
     end
 
     def relative!
-      self.class.new(path: path, absolute: false)
+      Namespace[path, false]
     end
 
     def empty?
@@ -57,13 +92,14 @@ module RBS
     end
 
     def ==(other)
+      return true if equal?(other)
       other.is_a?(Namespace) && other.path == path && other.absolute? == absolute?
     end
 
     alias eql? ==
 
     def hash
-      path.hash ^ absolute?.hash
+      @hash ||= path.hash ^ absolute?.hash
     end
 
     def split
@@ -87,14 +123,14 @@ module RBS
       raise unless name
       raise unless parent
 
-      TypeName.new(name: name, namespace: parent)
+      TypeName[parent, name]
     end
 
     def self.parse(string)
       if string.start_with?("::")
-        new(path: string.split("::").drop(1).map(&:to_sym), absolute: true)
+        self[string.split("::").drop(1).map(&:to_sym), true]
       else
-        new(path: string.split("::").map(&:to_sym), absolute: false)
+        self[string.split("::").map(&:to_sym), false]
       end
     end
 

data/lib/rbs/parser_aux.rb

@@ -121,12 +121,14 @@ module RBS
 
     def self.parse_inline_leading_annotation(source, range, variables: [])
       buf = buffer(source)
-      _parse_inline_leading_annotation(buf, range.begin || 0, range.end || buf.last_position, variables)
+      byte_range = byte_range(range, buf.content)
+      _parse_inline_leading_annotation(buf, byte_range.begin || 0, byte_range.end || buf.content.bytesize, variables)
     end
 
     def self.parse_inline_trailing_annotation(source, range, variables: [])
       buf = buffer(source)
-      _parse_inline_trailing_annotation(buf, range.begin || 0, range.end || buf.last_position, variables)
+      byte_range = byte_range(range, buf.content)
+      _parse_inline_trailing_annotation(buf, byte_range.begin || 0, byte_range.end || buf.content.bytesize, variables)
     end
 
     def self.byte_range(char_range, content)

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/prototype/runtime.rb

@@ -77,6 +77,8 @@ module RBS
       attr_accessor :outline
 
       def initialize(patterns:, env:, merge:, todo: false, owners_included: [])
+        Kernel.warn("RBS::Prototype::Runtime is deprecated. See https://github.com/ruby/rbs/issues/2841")
+
         @patterns = patterns
         @decls = nil
         @modules = {}

data/lib/rbs/resolver/type_name_resolver.rb

@@ -29,11 +29,9 @@ module RBS
         new(all_names, aliases)
       end
 
-      def try_cache(query)
-        cache.fetch(query) do
-          result = yield
-          cache[query] = result
-        end
+      def try_cache(type_name, context)
+        inner = cache[context] ||= {}
+        inner.fetch(type_name) { inner[type_name] = yield }
       end
 
       def resolve(type_name, context:)
@@ -41,7 +39,7 @@ module RBS
           return type_name
         end
 
-        try_cache([type_name, context]) do
+        try_cache(type_name, context) do
           if type_name.class?
             resolve_namespace0(type_name, context, Set.new) || nil
           else
@@ -51,7 +49,7 @@ module RBS
               resolve_type_name(type_name.name, context)
             else
               if namespace = resolve_namespace0(namespace.to_type_name, context, Set.new)
-                type_name = TypeName.new(name: type_name.name, namespace: namespace.to_namespace)
+                type_name = TypeName[namespace.to_namespace, type_name.name]
                 has_type_name?(type_name)
               end
             end
@@ -68,7 +66,7 @@ module RBS
           raise "Type name must be a class name: #{type_name}"
         end
 
-        try_cache([type_name, context]) do
+        try_cache(type_name, context) do
           ns = resolve_namespace0(type_name, context, Set.new) or return ns
         end
       end
@@ -93,10 +91,10 @@ module RBS
             resolve_type_name(type_name, outer)
           else
             has_type_name?(inner) or raise "Context must be normalized: #{inner.inspect}"
-            has_type_name?(TypeName.new(name: type_name, namespace: inner.to_namespace)) || resolve_type_name(type_name, outer)
+            has_type_name?(TypeName[inner.to_namespace, type_name]) || resolve_type_name(type_name, outer)
           end
         else
-          type_name = TypeName.new(name: type_name, namespace: Namespace.root)
+          type_name = TypeName[Namespace.root, type_name]
           has_type_name?(type_name)
         end
       end
@@ -109,11 +107,11 @@ module RBS
             resolve_head_namespace(head, outer)
           when TypeName
             has_type_name?(inner) or raise "Context must be normalized: #{inner.inspect}"
-            type_name = TypeName.new(name: head, namespace: inner.to_namespace)
+            type_name = TypeName[inner.to_namespace, head]
             has_type_name?(type_name) || aliased_name?(type_name) || resolve_head_namespace(head, outer)
           end
         else
-          type_name = TypeName.new(name: head, namespace: Namespace.root)
+          type_name = TypeName[Namespace.root, head]
           has_type_name?(type_name) || aliased_name?(type_name)
         end
       end
@@ -140,7 +138,7 @@ module RBS
 
         head =
           if type_name.absolute?
-            root_name = TypeName.new(name: head, namespace: Namespace.root)
+            root_name = TypeName[Namespace.root, head]
             has_type_name?(root_name) || aliased_name?(root_name)
           else
             resolve_head_namespace(head, context)
@@ -152,7 +150,7 @@ module RBS
           end
 
           tail.inject(head) do |namespace, name|
-            type_name = TypeName.new(name: name, namespace: namespace.to_namespace)
+            type_name = TypeName[namespace.to_namespace, name]
             case
             when has_type_name?(type_name)
               type_name

data/lib/rbs/type_name.rb

@@ -22,14 +22,40 @@ module RBS
               end
     end
 
+    # Process-wide flyweight cache. Two-level Hash keyed by canonical
+    # Namespace identity (outer uses `compare_by_identity`) and name
+    # Symbol.
+    @intern_mutex = Mutex.new
+    @intern_cache = {}  #: Hash[Namespace, Hash[Symbol, TypeName]]
+    @intern_cache.compare_by_identity
+
+    # Returns a canonical `TypeName` instance for the given `namespace` /
+    # `name` pair. The namespace is canonicalized through `Namespace.[]`
+    # so identity-based lookup works regardless of the caller passing a
+    # fresh `Namespace.new` or an already-interned instance.
+    def self.[](namespace, name)
+      ns = Namespace[namespace.path, namespace.absolute?]
+
+      inner = @intern_cache[ns]
+      if inner && (cached = inner[name])
+        return cached
+      end
+
+      @intern_mutex.synchronize do
+        inner = (@intern_cache[ns] ||= {})
+        inner[name] ||= new(namespace: ns, name: name)
+      end
+    end
+
     def ==(other)
+      return true if equal?(other)
       other.is_a?(self.class) && other.namespace == namespace && other.name == name
     end
 
     alias eql? ==
 
     def hash
-      namespace.hash ^ name.hash
+      @hash ||= namespace.hash ^ name.hash
     end
 
     def to_s
@@ -53,7 +79,7 @@ module RBS
     end
 
     def absolute!
-      self.class.new(namespace: namespace.absolute!, name: name)
+      TypeName[namespace.absolute!, name]
     end
 
     def absolute?
@@ -61,7 +87,7 @@ module RBS
     end
 
     def relative!
-      self.class.new(namespace: namespace.relative!, name: name)
+      TypeName[namespace.relative!, name]
     end
 
     def interface?
@@ -69,7 +95,7 @@ module RBS
     end
 
     def with_prefix(namespace)
-      self.class.new(namespace: namespace + self.namespace, name: name)
+      TypeName[namespace + self.namespace, name]
     end
 
     def split
@@ -80,23 +106,17 @@ module RBS
       if other.absolute?
         other
       else
-        TypeName.new(
-          namespace: self.to_namespace + other.namespace,
-          name: other.name
-        )
+        TypeName[self.to_namespace + other.namespace, other.name]
       end
     end
-    
+
     def self.parse(string)
       absolute = string.start_with?("::")
 
       *path, name = string.delete_prefix("::").split("::").map(&:to_sym)
       raise unless name
 
-      TypeName.new(
-        name: name,
-        namespace: RBS::Namespace.new(path: path, absolute: absolute)
-      )
+      TypeName[Namespace[path, absolute], name]
     end
   end
 end