rbs 0.18.0 → 1.0.0.pre

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,19 @@ 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}"]
+
+        RBS.logger.debug {
+          "Generating method definition: def #{with_name}(#{param_source.join(", ")}, &block) ..."
+        }
+
         [__LINE__ + 1, <<RUBY]
-def #{with_name}(*args, &block)
+def #{with_name}(#{param_source.join(", ")}, &block)
+  args = [#{param_source.join(", ")}]
   ::RBS.logger.debug { "#{full_method_name} with arguments: [" + args.map(&:inspect).join(", ") + "]" }
 
   begin
@@ -81,12 +88,18 @@ def #{with_name}(*args, &block)
 
     if block_given?
       receiver = self
-      result = __send__(:"#{without_name}", *args) do |*block_args|
+      block_receives_block = block.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.call(*block_args, &block2)
+                           else
+                             yield(*block_args)
+                           end
                          else
                            instance_exec(*block_args, &block)
                          end
@@ -117,7 +130,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 +178,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 +187,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

@@ -947,44 +947,100 @@ module RBS
       end
     end
 
+    class Block
+      attr_reader :type
+      attr_reader :required
+
+      def initialize(type:, required:)
+        @type = type
+        @required = required
+      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 +1049,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.0"
+  VERSION = "1.0.0.pre"
 end

data/lib/rbs/writer.rb

@@ -285,7 +285,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/definition.rbs

@@ -65,10 +65,15 @@ module RBS
       type t = Instance | Singleton
 
       class Instance
+        type source = :super | nil
+                    | AST::Members::Include | AST::Members::Extend | AST::Members::Prepend
+                    | AST::Declarations::Module::Self
+
         attr_reader name: TypeName
         attr_reader args: Array[Types::t]
+        attr_reader source: source
 
-        def initialize: (name: TypeName, args: Array[Types::t]) -> void
+        def initialize: (name: TypeName, args: Array[Types::t], source: source) -> void
       end
 
       class Singleton

data/sig/definition_builder.rbs

@@ -93,5 +93,8 @@ module RBS
     def validate_parameter_variance: (decl: AST::Declarations::Class | AST::Declarations::Module | AST::Declarations::Interface, methods: Hash[Symbol, Definition::Method]) -> void
 
     def expand_alias: (TypeName) -> Types::t
+
+    type attributes = AST::Members::AttrReader | AST::Members::AttrWriter | AST::Members::AttrAccessor
+    def build_attribute: (type_name: TypeName, definition: Definition, member: attributes, accessibility: Definition::accessibility) -> void
   end
 end

data/sig/errors.rbs

@@ -0,0 +1,20 @@
+module RBS
+  interface _Kinded
+    def kind: () -> (:instance | :singleton)
+  end
+
+  module MethodNameHelper : _Kinded
+    def method_name_string: () -> String
+  end
+
+  class InvalidTypeApplicationError < StandardError
+    attr_reader type_name: TypeName
+    attr_reader args: Array[Types::t]
+    attr_reader params: Array[Symbol]
+    attr_reader location: Location?
+
+    def initialize: (type_name: TypeName, args: Array[Types::t], params: Array[Symbol], location: Location?) -> void
+
+    def self.check!: (type_name: TypeName, args: Array[Types::t], params: Array[Symbol], location: Location?) -> void
+  end
+end

data/sig/members.rbs

@@ -91,14 +91,17 @@ module RBS
       end
 
       module Attribute
+        type kind = :instance | :singleton
+
         attr_reader name: Symbol
         attr_reader type: Types::t
+        attr_reader kind: kind
         attr_reader ivar_name: Symbol | false | nil
         attr_reader annotations: Array[Annotation]
         attr_reader location: Location?
         attr_reader comment: Comment?
 
-        def initialize: (name: Symbol, type: Types::t, ivar_name: Symbol | false | nil, annotations: Array[Annotation], location: Location?, comment: Comment?) -> void
+        def initialize: (name: Symbol, type: Types::t, ivar_name: Symbol | false | nil, kind: kind, annotations: Array[Annotation], location: Location?, comment: Comment?) -> void
 
         include _HashEqual
       end

data/sig/method_types.rbs

@@ -1,24 +1,11 @@
 module RBS
   class MethodType
-    class Block
-      attr_reader type: Types::Function
-      attr_reader required: bool
-
-      def initialize: (type: Types::Function, required: boolish) -> void
-
-      def ==: (untyped other) -> bool
-
-      def to_json: (*untyped) -> String
-
-      def sub: (Substitution) -> Block
-    end
-
     attr_reader type_params: Array[Symbol]
     attr_reader type: Types::Function
-    attr_reader block: Block?
+    attr_reader block: Types::Block?
     attr_reader location: Location?
 
-    def initialize: (type_params: Array[Symbol], type: Types::Function, block: Block?, location: Location?) -> void
+    def initialize: (type_params: Array[Symbol], type: Types::Function, block: Types::Block?, location: Location?) -> void
 
     def ==: (untyped other) -> bool
 
@@ -26,7 +13,7 @@ module RBS
 
     def sub: (Substitution) -> MethodType
 
-    def update: (?type_params: Array[Symbol], ?type: Types::Function, ?block: Block?, ?location: Location?) -> MethodType
+    def update: (?type_params: Array[Symbol], ?type: Types::Function, ?block: Types::Block?, ?location: Location?) -> MethodType
 
     def free_variables: (?Set[Symbol] set) -> Set[Symbol]
 

data/sig/type_name_resolver.rbs

@@ -1,10 +1,12 @@
 module RBS
   class TypeNameResolver
+    type context = Array[Namespace]
+
     class Query
       attr_reader type_name: TypeName
       attr_reader context: Array[Namespace]
 
-      def initialize: (type_name: TypeName, context: Array[Namespace]) -> void
+      def initialize: (type_name: TypeName, context: context) -> void
     end
 
     attr_reader all_names: Set[TypeName]
@@ -15,7 +17,7 @@ module RBS
 
     def add_names: (Array[TypeName]) -> self
 
-    def resolve: (TypeName, context: Array[Namespace]) -> TypeName?
+    def resolve: (TypeName, context: context) -> TypeName?
 
     def has_name?: (TypeName) -> TypeName?
 

data/sig/types.rbs

@@ -334,11 +334,27 @@ module RBS
       def has_keyword?: () -> bool
     end
 
+    class Block
+      attr_reader type: Types::Function
+      attr_reader required: boolish
+
+      def initialize: (type: Types::Function, required: boolish) -> void
+
+      def ==: (untyped other) -> bool
+
+      def to_json: (*untyped) -> String
+
+      def sub: (Substitution) -> Block
+
+      def map_type: () { (Types::t) -> Types::t } -> Block
+    end
+
     class Proc
       attr_reader type: Function
+      attr_reader block: Block?
       attr_reader location: Location?
 
-      def initialize: (location: Location?, type: Function) -> void
+      def initialize: (location: Location?, type: Function, block: Block?) -> void
 
       include _TypeBase
     end

data/sig/validator.rbs

@@ -0,0 +1,12 @@
+module RBS
+  class Validator
+    attr_reader env: Environment
+    attr_reader resolver: TypeNameResolver
+
+    def initialize: (env: Environment, resolver: TypeNameResolver) -> void
+
+    def absolute_type: (Types::t, context: TypeNameResolver::context) { (Types::t) -> TypeName } -> Types::t
+
+    def validate_type: (Types::t, context: TypeNameResolver::context) -> void
+  end
+end