rbs 2.2.2 → 2.3.0

data/lib/rbs/definition_builder.rb

@@ -140,7 +140,7 @@ module RBS
         case entry
         when Environment::ClassEntry, Environment::ModuleEntry
           ancestors = ancestor_builder.instance_ancestors(type_name)
-          args = Types::Variable.build(entry.type_params.each.map(&:name))
+          args = entry.type_params.map {|param| Types::Variable.new(name: param.name, location: param.location) }
           self_type = Types::ClassInstance.new(name: type_name, args: args, location: nil)
 
           Definition.new(type_name: type_name, entry: entry, self_type: self_type, ancestors: ancestors).tap do |definition|
@@ -425,7 +425,7 @@ module RBS
                         type: method_type.type.with_return_type(
                           Types::ClassInstance.new(
                             name: type_name,
-                            args: Types::Variable.build(entry.type_params.each.map(&:name)),
+                            args: entry.type_params.map {|param| Types::Variable.new(name: param.name, location: param.location) },
                             location: nil
                           )
                         )

data/lib/rbs/environment.rb

@@ -9,19 +9,23 @@ module RBS
     attr_reader :global_decls
 
     module ContextUtil
-      def context
-        @context ||= begin
-                       (outer + [decl]).each.with_object([Namespace.root]) do |decl, array|
-                         first = array.first or raise
-                         array.unshift(first + decl.name.to_namespace)
-                       end
-                     end
+      def calculate_context(decls)
+        decls.each.with_object([Namespace.root]) do |decl, array|
+          first = array.first or raise
+          array.unshift(first + decl.name.to_namespace)
+        end
       end
     end
 
     class MultiEntry
       D = _ = Struct.new(:decl, :outer, keyword_init: true) do
+        # @implements D[M]
+
         include ContextUtil
+
+        def context
+          @context ||= calculate_context(outer + [decl])
+        end
       end
 
       attr_reader :name
@@ -39,8 +43,6 @@ module RBS
 
       def validate_type_params
         unless decls.empty?
-          # @type var hd_decl: MultiEntry::D[module_decl]
-          # @type var tl_decls: Array[MultiEntry::D[module_decl]]
           hd_decl, *tl_decls = decls
           raise unless hd_decl
 
@@ -50,7 +52,7 @@ module RBS
             tl_params = tl_decl.decl.type_params
 
             unless compatible_params?(hd_params, tl_params)
-              raise GenericParameterMismatchError.new(name: name, decl: tl_decl.decl)
+              raise GenericParameterMismatchError.new(name: name, decl: _ = tl_decl.decl)
             end
           end
         end
@@ -86,6 +88,12 @@ module RBS
       end
     end
 
+    def foo
+      a = [1].sample()
+      return unless a
+      a + 1
+    end
+
     class ClassEntry < MultiEntry
       def primary
         @primary ||= begin
@@ -96,8 +104,6 @@ module RBS
     end
 
     class SingleEntry
-      include ContextUtil
-
       attr_reader :name
       attr_reader :outer
       attr_reader :decl
@@ -107,6 +113,12 @@ module RBS
         @decl = decl
         @outer = outer
       end
+
+      include ContextUtil
+
+      def context
+        @context = calculate_context(outer)
+      end
     end
 
     def initialize

data/lib/rbs/locator.rb

@@ -41,11 +41,7 @@ module RBS
         case decl
         when AST::Declarations::Class
           decl.type_params.each do |param|
-            if test_loc(pos, location: param.location)
-              array.unshift(param)
-              find_in_loc(pos, array: array, location: param.location)
-              return true
-            end
+            find_in_type_param(pos, type_param: param, array: array) and return true
           end
 
           if super_class = decl.super_class
@@ -66,11 +62,7 @@ module RBS
 
         when AST::Declarations::Module
           decl.type_params.each do |param|
-            if test_loc(pos, location: param.location)
-              array.unshift(param)
-              find_in_loc(pos, array: array, location: param.location)
-              return true
-            end
+            find_in_type_param(pos, type_param: param, array: array) and return true
           end
 
           decl.self_types.each do |self_type|
@@ -91,11 +83,7 @@ module RBS
 
         when AST::Declarations::Interface
           decl.type_params.each do |param|
-            if test_loc(pos, location: param.location)
-              array.unshift(param)
-              find_in_loc(pos, array: array, location: param.location)
-              return true
-            end
+            find_in_type_param(pos, type_param: param, array: array) and return true
           end
 
           decl.members.each do |member|
@@ -144,6 +132,10 @@ module RBS
       if test_loc(pos, location: method_type.location)
         array.unshift(method_type)
 
+        method_type.type_params.each do |param|
+          find_in_type_param(pos, type_param: param, array: array) and return true
+        end
+
         method_type.each_type do |type|
           find_in_type(pos, array: array, type: type) and break
         end
@@ -154,6 +146,23 @@ module RBS
       end
     end
 
+    def find_in_type_param(pos, type_param:, array:)
+      if test_loc(pos, location: type_param.location)
+        array.unshift(type_param)
+
+        if upper_bound = type_param.upper_bound
+          find_in_type(pos, type: upper_bound, array: array) or
+            find_in_loc(pos, location: type_param.location, array: array)
+        else
+          find_in_loc(pos, location: type_param.location, array: array)
+        end
+
+        true
+      else
+        false
+      end
+    end
+
     def find_in_type(pos, type:, array:)
       if test_loc(pos, location: type.location)
         array.unshift(type)

data/lib/rbs/prototype/rb.rb

@@ -338,7 +338,7 @@ module RBS
                   # Give up type prediction when node is MASGN.
                   Types::Bases::Any.new(location: nil)
                 else
-                  node_type(value_node)
+                  literal_to_type(value_node)
                 end
           decls << AST::Declarations::Constant.new(
             name: const_name,
@@ -408,7 +408,7 @@ module RBS
           name = lvasgn.children[0]
           fun.optional_positionals << Types::Function::Param.new(
             name: name,
-            type: node_type(lvasgn.children[1])
+            type: param_type(lvasgn.children[1])
           )
         end
 
@@ -429,7 +429,7 @@ module RBS
           when nil, :NODE_SPECIAL_REQUIRED_KEYWORD
             fun.required_keywords[name] = Types::Function::Param.new(name: name, type: untyped)
           when RubyVM::AbstractSyntaxTree::Node
-            fun.optional_keywords[name] = Types::Function::Param.new(name: name, type: node_type(value))
+            fun.optional_keywords[name] = Types::Function::Param.new(name: name, type: param_type(value))
           else
             raise "Unexpected keyword arg value: #{value}"
           end
@@ -477,9 +477,9 @@ module RBS
         when :DREGX
           BuiltinNames::Regexp.instance_type
         when :TRUE
-          BuiltinNames::TrueClass.instance_type
+          Types::Literal.new(literal: true, location: nil)
         when :FALSE
-          BuiltinNames::FalseClass.instance_type
+          Types::Literal.new(literal: false, location: nil)
         when :NIL
           Types::Bases::Nil.new(location: nil)
         when :LIT
@@ -536,6 +536,14 @@ module RBS
             value_type = types_to_union_type(value_types)
             BuiltinNames::Hash.instance_type([key_type, value_type])
           end
+        when :CALL
+          receiver, method_name, * = node.children
+          case method_name
+          when :freeze, :tap, :itself, :dup, :clone, :taint, :untaint, :extend
+            literal_to_type(receiver)
+          else
+            default
+          end
         else
           untyped
         end
@@ -570,7 +578,7 @@ module RBS
         end
       end
 
-      def node_type(node, default: Types::Bases::Any.new(location: nil))
+      def param_type(node, default: Types::Bases::Any.new(location: nil))
         case node.type
         when :LIT
           case node.children[0]
@@ -602,6 +610,9 @@ module RBS
         end
       end
 
+      # backward compatible
+      alias node_type param_type
+
       def private
         @private ||= AST::Members::Private.new(location: nil)
       end

data/lib/rbs/resolver/constant_resolver.rb

@@ -0,0 +1,192 @@
+module RBS
+  module Resolver
+    class ConstantResolver
+      class Table
+        attr_reader :children_table, :toplevel
+        attr_reader :constants_table
+
+        def initialize(environment)
+          @children_table = {}
+          @toplevel = {}
+
+          @constants_table = {}
+
+          environment.class_decls.each_key do |name|
+            children_table[name] = {}
+          end
+
+          environment.class_decls.each do |name, entry|
+            unless name.namespace.empty?
+              parent = name.namespace.to_type_name
+
+              table = children_table[parent] or raise
+              constant = constant_of_module(name, entry)
+            else
+              table = toplevel
+              constant = constant_of_module(name, entry)
+            end
+
+            table[name.name] = constant
+            constants_table[name] = constant
+          end
+
+          environment.constant_decls.each do |name, entry|
+            unless name.namespace.empty?
+              parent = name.namespace.to_type_name
+
+              table = children_table[parent] or raise
+              constant = constant_of_constant(name, entry)
+            else
+              table = toplevel
+              constant = constant_of_constant(name, entry)
+            end
+
+            table[name.name] = constant
+          end
+        end
+
+        def children(name)
+          children_table[name]
+        end
+
+        def constant(name)
+          constants_table[name]
+        end
+
+        def constant_of_module(name, entry)
+          type = Types::ClassSingleton.new(
+            name: name,
+            location: nil
+          )
+
+          Constant.new(name: name, type: type, entry: entry)
+        end
+
+        def constant_of_constant(name, entry)
+          Constant.new(name: name, type: entry.decl.type, entry: entry)
+        end
+      end
+
+      attr_reader :builder, :table
+      attr_reader :context_constants_cache, :child_constants_cache
+
+      def initialize(builder:)
+        @builder = builder
+        @table = Table.new(builder.env)
+        @context_constants_cache = {}
+        @child_constants_cache = {}
+      end
+
+      def resolve(name, context:)
+        cs = constants(context) or raise "Broken context is given"
+        cs[name]
+      end
+
+      def constants(context)
+        unless context_constants_cache.key?(context)
+          load_context_constants(context)
+        end
+
+        context_constants_cache[context]
+      end
+
+      def resolve_child(module_name, name)
+        children(module_name)[name]
+      end
+
+      def children(module_name)
+        unless child_constants_cache.key?(module_name)
+          load_child_constants(module_name)
+        end
+
+        child_constants_cache[module_name] or raise
+      end
+
+      def load_context_constants(context)
+        # @type var consts: Hash[Symbol, Constant]
+        consts = {}
+
+        if context
+          if last = context[1]
+            constants_from_ancestors(last, constants: consts)
+          end
+        end
+        constants_from_context(context, constants: consts) or return
+        constants_itself(context, constants: consts)
+
+        context_constants_cache[context] = consts
+      end
+
+      def load_child_constants(name)
+        # @type var constants: Hash[Symbol, Constant]
+        constants = {}
+
+        if table.children(name)
+          builder.ancestor_builder.instance_ancestors(name).ancestors.each do |ancestor|
+            if ancestor.is_a?(Definition::Ancestor::Instance)
+              if ancestor.name == BuiltinNames::Object.name
+                if name != BuiltinNames::Object.name
+                  next
+                end
+              end
+
+              case ancestor.source
+              when AST::Members::Include, :super, nil
+                consts = table.children(ancestor.name) or raise
+                constants.merge!(consts)
+              end
+            end
+          end
+        end
+
+        child_constants_cache[name] = constants
+      end
+
+      def constants_from_context(context, constants:)
+        if context
+          parent, last = context
+
+          constants_from_context(parent, constants: constants) or return false
+
+          if last
+            consts = table.children(last) or return false
+            constants.merge!(consts)
+          end
+        else
+          constants.merge!(table.toplevel)
+        end
+
+        true
+      end
+
+      def constants_from_ancestors(module_name, constants:)
+        builder.ancestor_builder.instance_ancestors(module_name).ancestors.each do |ancestor|
+          if ancestor.is_a?(Definition::Ancestor::Instance)
+            case ancestor.source
+            when AST::Members::Include, :super, nil
+              consts = table.children(ancestor.name) or raise
+              constants.merge!(consts)
+            end
+          end
+        end
+      end
+
+      def constants_itself(context, constants:)
+        if context
+          _, typename = context
+
+          if typename
+            if (ns = typename.namespace).empty?
+              constant = table.toplevel[typename.name] or raise
+            else
+              hash = table.children(ns.to_type_name) or raise
+              constant = hash[typename.name]
+            end
+
+            constants[typename.name] = constant
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rbs/resolver/type_name_resolver.rb

@@ -0,0 +1,55 @@
+module RBS
+  module Resolver
+    class TypeNameResolver
+      attr_reader :all_names
+      attr_reader :cache
+
+      def initialize(env)
+        @all_names = Set[]
+        @cache = {}
+
+        all_names.merge(env.class_decls.keys)
+        all_names.merge(env.interface_decls.keys)
+        all_names.merge(env.alias_decls.keys)
+      end
+
+      def try_cache(query)
+        cache.fetch(query) do
+          result = yield
+          cache[query] = result
+        end
+      end
+
+      def resolve(type_name, context:)
+        if type_name.absolute?
+          return type_name
+        end
+
+        try_cache([type_name, context]) do
+          resolve_in(type_name, context)
+        end
+      end
+
+      def resolve_in(type_name, context)
+        if context
+          parent, child = context
+          case child
+          when false
+            resolve_in(type_name, parent)
+          when TypeName
+            name = type_name.with_prefix(child.to_namespace)
+            has_name?(name) || resolve_in(type_name, parent)
+          end
+        else
+          has_name?(type_name.absolute!)
+        end
+      end
+
+      def has_name?(full_name)
+        if all_names.include?(full_name)
+          full_name
+        end
+      end
+    end
+  end
+end

data/lib/rbs/type_name.rb

@@ -69,6 +69,21 @@ module RBS
     def with_prefix(namespace)
       self.class.new(namespace: namespace + self.namespace, name: name)
     end
+
+    def split
+      namespace.path + [name]
+    end
+
+    def +(other)
+      if other.absolute?
+        other
+      else
+        TypeName.new(
+          namespace: self.to_namespace + other.namespace,
+          name: other.name
+        )
+      end
+    end
   end
 end
 

data/lib/rbs/version.rb

@@ -1,3 +1,3 @@
 module RBS
-  VERSION = "2.2.2"
+  VERSION = "2.3.0"
 end

data/lib/rbs.rb

@@ -28,6 +28,8 @@ require "rbs/definition_builder/method_builder"
 require "rbs/variance_calculator"
 require "rbs/substitution"
 require "rbs/constant"
+require "rbs/resolver/constant_resolver"
+require "rbs/resolver/type_name_resolver"
 require "rbs/constant_table"
 require "rbs/ast/comment"
 require "rbs/writer"

data/schema/members.json

@@ -37,9 +37,12 @@
         },
         "overload": {
           "type": "boolean"
+        },
+        "visibility": {
+          "enum": ["public", "private", null]
         }
       },
-      "required": ["member", "kind", "types", "comment", "annotations", "location"]
+      "required": ["member", "kind", "types", "comment", "annotations", "location", "visibility"]
     },
     "variable": {
       "title": "Declaration for instance variables and class variables",

data/sig/environment.rbs

@@ -2,32 +2,40 @@ module RBS
   class Environment
     type module_decl = AST::Declarations::Class | AST::Declarations::Module
 
-    interface _WithContext
-      def outer: () -> Array[module_decl]
+    interface _ModuleOrClass
+      def name: () -> TypeName
 
-      def decl: () -> untyped
+      def type_params: () -> Array[AST::TypeParam]
     end
 
-    module ContextUtil : _WithContext
-      def context: () -> Array[Namespace]
+    interface _NamedDecl
+      def name: () -> TypeName
+    end
+
+    module ContextUtil
+      def calculate_context: (Array[_NamedDecl]) -> Array[Namespace]
     end
 
-    class MultiEntry
-      class D[M]
+    class MultiEntry[M < _ModuleOrClass]
+      class D[M < _ModuleOrClass]
         attr_reader decl: M
         attr_reader outer: Array[module_decl]
 
-        def initialize: (decl: module_decl, outer: Array[module_decl]) -> void
+        def initialize: (decl: M, outer: Array[module_decl]) -> void
 
         include ContextUtil
+
+        @context: Array[Namespace]
+
+        def context: () -> Array[Namespace]
       end
 
       attr_reader name: TypeName
-      attr_reader decls: Array[untyped]
+      attr_reader decls: Array[D[M]]
 
       def initialize: (name: TypeName) -> void
 
-      def insert: (decl: module_decl, outer: Array[module_decl]) -> void
+      def insert: (decl: M, outer: Array[module_decl]) -> void
 
       def validate_type_params: () -> void
 
@@ -35,29 +43,28 @@ module RBS
 
       def type_params: () -> Array[AST::TypeParam]
 
-      def primary: () -> D[module_decl]
+      def primary: () -> D[M]
     end
 
-    class ModuleEntry < MultiEntry
-      attr_reader decls: Array[MultiEntry::D[AST::Declarations::Module]]
-      attr_reader primary: MultiEntry::D[AST::Declarations::Module]
-
+    class ModuleEntry < MultiEntry[AST::Declarations::Module]
       def self_types: () -> Array[AST::Declarations::Module::Self]
     end
 
-    class ClassEntry < MultiEntry
-      attr_reader decls: Array[MultiEntry::D[AST::Declarations::Class]]
-      attr_reader primary: MultiEntry::D[AST::Declarations::Class]
+    class ClassEntry < MultiEntry[AST::Declarations::Class]
     end
 
     class SingleEntry[N, D]
-      include ContextUtil
-
       attr_reader name: N
       attr_reader decl: D
       attr_reader outer: Array[module_decl]
 
       def initialize: (name: N, decl: D, outer: Array[module_decl]) -> void
+
+      include ContextUtil
+
+      @context: Array[Namespace]
+
+      def context: () -> Array[Namespace]
     end
 
     # Top level declarations.
@@ -75,7 +82,7 @@ module RBS
 
     def self.from_loader: (EnvironmentLoader) -> Environment
 
-    def cache_name: [Key, D] (Hash[Key, SingleEntry[Key, D]] cache, name: Key, decl: D, outer: Array[module_decl]) -> SingleEntry[Key, D]
+    def cache_name: [N, D] (Hash[N, SingleEntry[N, D]] cache, name: N, decl: D, outer: Array[module_decl]) -> SingleEntry[N, D]
 
     def insert_decl: (AST::Declarations::t, outer: Array[module_decl], namespace: Namespace) -> void