rbs 0.18.1 → 1.0.0.pre2

data/lib/rbs/substitution.rb

@@ -3,6 +3,10 @@ module RBS
     attr_reader :mapping
     attr_accessor :instance_type
 
+    def empty?
+      mapping.empty? && instance_type.nil?
+    end
+
     def initialize()
       @mapping = {}
     end

data/lib/rbs/test.rb

@@ -100,6 +100,8 @@ end
 
 unless ::Proc.instance_methods.include?(:ruby2_keywords)
   class Proc
-    def ruby2_keywords; end
+    def ruby2_keywords
+      self
+    end
   end
 end

data/lib/rbs/test/hook.rb

@@ -67,12 +67,20 @@ module RBS
         end
       end
 
-      def self.hook_method_source(prefix, method_name, key, random:)
+      def self.hook_method_source(prefix, method_name, key, random:, params:)
         with_name, without_name = alias_names(method_name, random)
         full_method_name = "#{prefix}#{method_name}"
 
+        param_source = params.take_while {|param| param[0] == :req }.map(&:last) + ["*rest_args__#{random}"]
+        block_param = "block__#{random}"
+
+        RBS.logger.debug {
+          "Generating method definition: def #{with_name}(#{param_source.join(", ")}, &#{block_param}) ..."
+        }
+
         [__LINE__ + 1, <<RUBY]
-def #{with_name}(*args, &block)
+def #{with_name}(#{param_source.join(", ")}, &#{block_param})
+  args = [#{param_source.join(", ")}]
   ::RBS.logger.debug { "#{full_method_name} with arguments: [" + args.map(&:inspect).join(", ") + "]" }
 
   begin
@@ -81,14 +89,20 @@ def #{with_name}(*args, &block)
 
     if block_given?
       receiver = self
-      result = __send__(:"#{without_name}", *args) do |*block_args|
+      block_receives_block = #{block_param}.parameters.last&.yield_self {|type, _| type == :block }
+
+      wrapped_block = proc do |*block_args, &block2|
         return_from_block = false
 
         begin
           block_result = if receiver.equal?(self)
-                           yield(*block_args)
+                           if block_receives_block
+                             #{block_param}.call(*block_args, &block2)
+                           else
+                             yield(*block_args)
+                           end
                          else
-                           instance_exec(*block_args, &block)
+                           instance_exec(*block_args, &#{block_param})
                          end
 
           return_from_block = true
@@ -117,7 +131,9 @@ def #{with_name}(*args, &block)
         end
 
         block_result
-      end
+      end.ruby2_keywords
+
+      result = __send__(:"#{without_name}", *args, &wrapped_block)
     else
       result = __send__(:"#{without_name}", *args)
     end
@@ -163,7 +179,8 @@ RUBY
 
       def self.hook_instance_method(klass, method, key:)
         random = SecureRandom.hex(4)
-        line, source = hook_method_source("#{klass}#", method, key, random: random)
+        params = klass.instance_method(method).parameters
+        line, source = hook_method_source("#{klass}#", method, key, random: random, params: params)
 
         klass.module_eval(source, __FILE__, line)
         setup_alias_method_chain klass, method, random: random
@@ -171,7 +188,8 @@ RUBY
 
       def self.hook_singleton_method(klass, method, key:)
         random = SecureRandom.hex(4)
-        line, source = hook_method_source("#{klass}.",method, key, random: random)
+        params = klass.method(method).parameters
+        line, source = hook_method_source("#{klass}.",method, key, random: random, params: params)
 
         klass.singleton_class.module_eval(source, __FILE__, line)
         setup_alias_method_chain klass.singleton_class, method, random: random

data/lib/rbs/types.rb

@@ -943,48 +943,108 @@ module RBS
       end
 
       def has_keyword?
-        !required_keywords.empty? || !optional_keywords.empty? || rest_keywords
+        if !required_keywords.empty? || !optional_keywords.empty? || rest_keywords
+          true
+        else
+          false
+        end
+      end
+    end
+
+    class Block
+      attr_reader :type
+      attr_reader :required
+
+      def initialize(type:, required:)
+        @type = type
+        @required = required ? true : false
+      end
+
+      def ==(other)
+        other.is_a?(Block) &&
+          other.type == type &&
+          other.required == required
+      end
+
+      def to_json(*a)
+        {
+          type: type,
+          required: required
+        }.to_json(*a)
+      end
+
+      def sub(s)
+        self.class.new(
+          type: type.sub(s),
+          required: required
+        )
+      end
+
+      def map_type(&block)
+        Block.new(
+          required: required,
+          type: type.map_type(&block)
+        )
       end
     end
 
     class Proc
       attr_reader :type
+      attr_reader :block
       attr_reader :location
 
-      def initialize(location:, type:)
+      def initialize(location:, type:, block:)
         @type = type
+        @block = block
         @location = location
       end
 
       def ==(other)
-        other.is_a?(Proc) && other.type == type
+        other.is_a?(Proc) && other.type == type && other.block == block
       end
 
       alias eql? ==
 
       def hash
-        self.class.hash ^ type.hash
+        self.class.hash ^ type.hash ^ block.hash
       end
 
       def free_variables(set = Set[])
         type.free_variables(set)
+        block&.type&.free_variables(set)
+        set
       end
 
       def to_json(*a)
-        { class: :proc, type: type, location: location }.to_json(*a)
+        {
+          class: :proc,
+          type: type,
+          block: block,
+          location: location
+        }.to_json(*a)
       end
 
       def sub(s)
-        self.class.new(type: type.sub(s), location: location)
+        self.class.new(type: type.sub(s), block: block&.sub(s), location: location)
       end
 
       def to_s(level = 0)
-        "^(#{type.param_to_s}) -> #{type.return_to_s}".lstrip
+        case
+        when b = block
+          if b.required
+            "^(#{type.param_to_s}) { (#{b.type.param_to_s}) -> #{b.type.return_to_s} } -> #{type.return_to_s}"
+          else
+            "^(#{type.param_to_s}) ?{ (#{b.type.param_to_s}) -> #{b.type.return_to_s} } -> #{type.return_to_s}"
+          end
+        else
+          "^(#{type.param_to_s}) -> #{type.return_to_s}"
+        end
       end
 
       def each_type(&block)
         if block
           type.each_type(&block)
+          self.block&.type&.each_type(&block)
         else
           enum_for :each_type
         end
@@ -993,6 +1053,7 @@ module RBS
       def map_type_name(&block)
         Proc.new(
           type: type.map_type_name(&block),
+          block: self.block&.map_type {|type| type.map_type_name(&block) },
           location: location
         )
       end

data/lib/rbs/validator.rb

@@ -18,8 +18,9 @@ module RBS
     def validate_type(type, context:)
       case type
       when Types::ClassInstance, Types::Interface
+        # @type var type: Types::ClassInstance | Types::Interface
         if type.name.namespace.relative?
-          type = absolute_type(type, context: context) do |type|
+          type = _ = absolute_type(type, context: context) do |_|
             NoTypeFoundError.check!(type.name.absolute!, env: env, location: type.location)
           end
         end
@@ -43,7 +44,8 @@ module RBS
         )
 
       when Types::Alias, Types::ClassSingleton
-        type = absolute_type(type, context: context) { type.name.absolute! }
+        # @type var type: Types::Alias | Types::ClassSingleton
+        type = _ = absolute_type(type, context: context) { type.name.absolute! }
         NoTypeFoundError.check!(type.name, env: env, location: type.location)
       end
 

data/lib/rbs/variance_calculator.rb

@@ -86,7 +86,11 @@ module RBS
     end
 
     def in_inherit(name:, args:, variables:)
-      type = Types::ClassInstance.new(name: name, args: args, location: nil)
+      type = if name.class?
+               Types::ClassInstance.new(name: name, args: args, location: nil)
+             else
+               Types::Interface.new(name: name, args: args, location: nil)
+             end
 
       Result.new(variables: variables).tap do |result|
         type(type, result: result, context: :covariant)

data/lib/rbs/version.rb

@@ -1,3 +1,3 @@
 module RBS
-  VERSION = "0.18.1"
+  VERSION = "1.0.0.pre2"
 end

data/lib/rbs/writer.rb

@@ -232,10 +232,11 @@ module RBS
     def method_name(name)
       s = name.to_s
 
-      if /\A#{Parser::KEYWORDS_RE}\z/.match?(s)
-        "`#{s}`"
-      else
+      if [:tOPERATOR, :kAMP, :kHAT, :kSTAR, :kLT, :kEXCLAMATION, :kSTAR2, :kBAR].include?(Parser::PUNCTS[s]) ||
+          (/\A[a-zA-Z_]\w*[?!=]?\z/.match?(s) && !/\Aself\??\z/.match?(s))
         s
+      else
+        "`#{s}`"
       end
     end
 
@@ -285,7 +286,15 @@ module RBS
             else
               "(#{attr.ivar_name})"
             end
-      "attr_#{kind} #{attr.name}#{var}: #{attr.type}"
+
+      receiver = case attr.kind
+                 when :singleton
+                   "self."
+                 when :instance
+                   ""
+                 end
+
+      "attr_#{kind} #{receiver}#{attr.name}#{var}: #{attr.type}"
     end
 
     def preserve_empty_line(prev, decl)

data/schema/members.json

@@ -165,6 +165,10 @@
         "name": {
           "type": "string"
         },
+        "kind": {
+          "type": "string",
+          "enum": ["instance", "singleton"]
+        },
         "type": {
           "$ref": "types.json"
         },
@@ -194,7 +198,7 @@
           "$ref": "location.json"
         }
       },
-      "required": ["member", "name", "ivar_name", "type", "annotations", "comment", "location"]
+      "required": ["member", "name", "ivar_name", "type", "annotations", "kind", "comment", "location"]
     },
     "visibility": {
       "title": "Visibility specifier",

data/sig/ancestor_builder.rbs

@@ -0,0 +1,98 @@
+module RBS
+  class DefinitionBuilder
+    class AncestorBuilder
+      class OneAncestors
+        attr_reader type_name: TypeName
+        attr_reader params: Array[Symbol]?
+        attr_reader super_class: Definition::Ancestor::t?
+        attr_reader self_types: Array[Definition::Ancestor::Instance]?
+        attr_reader included_modules: Array[Definition::Ancestor::Instance]?
+        attr_reader included_interfaces: Array[Definition::Ancestor::Instance]?
+        attr_reader prepended_modules: Array[Definition::Ancestor::Instance]?
+        attr_reader extended_modules: Array[Definition::Ancestor::Instance]?
+        attr_reader extended_interfaces: Array[Definition::Ancestor::Instance]?
+
+        def initialize: (type_name: TypeName,
+                            params: Array[Symbol]?,
+                       super_class: Definition::Ancestor::t?,
+                        self_types: Array[Definition::Ancestor::Instance]?,
+                  included_modules: Array[Definition::Ancestor::Instance]?,
+               included_interfaces: Array[Definition::Ancestor::Instance]?,
+                 prepended_modules: Array[Definition::Ancestor::Instance]?,
+                  extended_modules: Array[Definition::Ancestor::Instance]?,
+               extended_interfaces: Array[Definition::Ancestor::Instance]?) -> void
+
+        def each_ancestor: { (Definition::Ancestor::t) -> void } -> void
+                         | -> Enumerator[Definition::Ancestor::t, void]
+
+        def self.class_instance: (type_name: TypeName, params: Array[Symbol], super_class: Definition::Ancestor::t?) -> instance
+
+        def self.singleton: (type_name: TypeName, super_class: Definition::Ancestor::t?) -> instance
+
+        def self.module_instance: (type_name: TypeName, params: Array[Symbol]) -> instance
+
+        def self.interface: (type_name: TypeName, params: Array[Symbol]) -> instance
+
+        def each_included_module: () { (Definition::Ancestor::Instance) -> void } -> void
+                                | () -> Enumerator[Definition::Ancestor::Instance, void]
+
+        def each_included_interface: () { (Definition::Ancestor::Instance) -> void } -> void
+                                   | () -> Enumerator[Definition::Ancestor::Instance, void]
+
+        def each_prepended_module: () { (Definition::Ancestor::Instance) -> void } -> void
+                                 | () -> Enumerator[Definition::Ancestor::Instance, void]
+
+        def each_extended_module: () { (Definition::Ancestor::Instance) -> void } -> void
+                                | () -> Enumerator[Definition::Ancestor::Instance, void]
+
+        def each_extended_interface: () { (Definition::Ancestor::Instance) -> void } -> void
+                                   | () -> Enumerator[Definition::Ancestor::Instance, void]
+
+        def each_self_type: () { (Definition::Ancestor::Instance) -> void } -> void
+                          | () -> Enumerator[Definition::Ancestor::Instance, void]
+      end
+
+      attr_reader env: Environment
+
+      attr_reader one_instance_ancestors_cache: Hash[TypeName, OneAncestors]
+      attr_reader instance_ancestors_cache: Hash[TypeName, Definition::InstanceAncestors]
+
+      attr_reader one_singleton_ancestors_cache: Hash[TypeName, OneAncestors]
+      attr_reader singleton_ancestors_cache: Hash[TypeName, Definition::SingletonAncestors]
+
+      attr_reader one_interface_ancestors_cache: Hash[TypeName, OneAncestors]
+      attr_reader interface_ancestors_cache: Hash[TypeName, Definition::InstanceAncestors]
+
+      def initialize: (env: Environment) -> void
+
+      def validate_super_class!: (TypeName, Environment::ClassEntry) -> void
+
+      def one_instance_ancestors: (TypeName) -> OneAncestors
+
+      def one_singleton_ancestors: (TypeName) -> OneAncestors
+
+      def one_interface_ancestors: (TypeName) -> OneAncestors
+
+      def instance_ancestors: (TypeName, ?building_ancestors: Array[Definition::Ancestor::t]) -> Definition::InstanceAncestors
+
+      def singleton_ancestors: (TypeName, ?building_ancestors: Array[Definition::Ancestor::t]) -> Definition::SingletonAncestors
+
+      def interface_ancestors: (TypeName, ?building_ancestors: Array[Definition::Ancestor::t]) -> Definition::InstanceAncestors
+
+      def mixin_ancestors: (Environment::ClassEntry | Environment::ModuleEntry,
+                            included_modules: Array[Definition::Ancestor::Instance]?,
+                         included_interfaces:Array[Definition::Ancestor::Instance]?,
+                           prepended_modules: Array[Definition::Ancestor::Instance]?,
+                            extended_modules: Array[Definition::Ancestor::Instance]?,
+                         extended_interfaces: Array[Definition::Ancestor::Instance]?) -> void
+
+      def mixin_ancestors0: (AST::Declarations::Class | AST::Declarations::Module | AST::Declarations::Interface,
+                             align_params: Substitution?,
+                         included_modules: Array[Definition::Ancestor::Instance]?,
+                      included_interfaces:Array[Definition::Ancestor::Instance]?,
+                        prepended_modules: Array[Definition::Ancestor::Instance]?,
+                         extended_modules: Array[Definition::Ancestor::Instance]?,
+                      extended_interfaces: Array[Definition::Ancestor::Instance]?) -> void
+    end
+  end
+end

data/sig/declarations.rbs

@@ -73,8 +73,9 @@ module RBS
         class Super
           attr_reader name: TypeName
           attr_reader args: Array[Types::t]
+          attr_reader location: Location?
 
-          def initialize: (name: TypeName, args: Array[Types::t]) -> void
+          def initialize: (name: TypeName, args: Array[Types::t], location: Location?) -> void
 
           include _HashEqual
           include _ToJson
@@ -130,21 +131,6 @@ module RBS
         include _ToJson
       end
 
-      class Extension < Base
-        attr_reader name: TypeName
-        attr_reader type_params: ModuleTypeParams
-        attr_reader extension_name: Symbol
-        attr_reader members: Array[Members::t]
-        attr_reader annotations: Array[Annotation]
-        attr_reader location: Location?
-        attr_reader comment: Comment?
-
-        def initialize: (name: TypeName, type_params: ModuleTypeParams, extension_name: Symbol, members: Array[Members::t], annotations: Array[Annotation], location: Location?, comment: Comment?) -> void
-
-        include _HashEqual
-        include _ToJson
-      end
-
       class Interface
         type member = Members::t
 
@@ -157,6 +143,8 @@ module RBS
 
         def initialize: (name: TypeName, type_params: ModuleTypeParams, members: Array[member], annotations: Array[Annotation], location: Location?, comment: Comment?) -> void
 
+        include MixinHelper
+
         include _HashEqual
         include _ToJson
       end