rbs 0.18.1 → 1.0.0.pre2

data/lib/rbs/parser.y

@@ -20,7 +20,7 @@ class RBS::Parser
   nonassoc kARROW
   preclow
 
-  expect 2
+  expect 5
 
 rule
 
@@ -50,7 +50,6 @@ rule
     | interface_decl
     | module_decl
     | class_decl
-    | extension_decl
 
   start_new_scope: { start_new_variables_scope }
   start_merged_scope: { start_merged_variables_scope }
@@ -61,24 +60,6 @@ rule
         result = val[1].unshift(Annotation.new(string: val[0].value, location: val[0].location))
       }
 
-  extension_decl:
-      annotations kEXTENSION start_new_scope class_name type_params kLPAREN extension_name kRPAREN class_members kEND {
-        reset_variable_scope
-
-        location = val[1].location + val[9].location
-        result = Declarations::Extension.new(
-          name: val[3].value,
-          type_params: val[4]&.value || [],
-          extension_name: val[6].value.to_sym,
-          members: val[8],
-          annotations: val[0],
-          location: location,
-          comment: leading_comment(val[0].first&.location || location)
-        )
-      }
-
-  extension_name: tUIDENT | tLIDENT
-
   class_decl:
       annotations kCLASS start_new_scope class_name module_type_params super_class class_members kEND {
         reset_variable_scope
@@ -99,11 +80,13 @@ rule
       { result = nil }
     | kLT class_name {
         result = Declarations::Class::Super.new(name: val[1].value,
-                                                args: [])
+                                                args: [],
+                                                location: val[1].location)
       }
     | kLT class_name kLBRACKET type_list kRBRACKET {
         result = Declarations::Class::Super.new(name: val[1].value,
-                                                args: val[3])
+                                                args: val[3],
+                                                location: val[1].location + val[4].location)
       }
 
   module_decl:
@@ -202,57 +185,67 @@ rule
     | alias_member
     | signature
 
+  attribute_kind:
+      { result = :instance }
+    | kSELF kDOT { result = :singleton }
+
   attribute_member:
-      annotations kATTRREADER keyword type {
-        location = val[1].location + val[3].location
-        result = Members::AttrReader.new(name: val[2].value,
+      annotations kATTRREADER attribute_kind keyword type {
+        location = val[1].location + val[4].location
+        result = Members::AttrReader.new(name: val[3].value,
                                          ivar_name: nil,
-                                         type: val[3],
+                                         type: val[4],
+                                         kind: val[2],
                                          annotations: val[0],
                                          location: location,
                                          comment: leading_comment(val[0].first&.location || location))
       }
-    | annotations kATTRREADER method_name attr_var_opt kCOLON type {
-        location = val[1].location + val[5].location
-        result = Members::AttrReader.new(name: val[2].value.to_sym,
-                                         ivar_name: val[3],
-                                         type: val[5],
+    | annotations kATTRREADER attribute_kind method_name attr_var_opt kCOLON type {
+        location = val[1].location + val[6].location
+        result = Members::AttrReader.new(name: val[3].value.to_sym,
+                                         ivar_name: val[4],
+                                         type: val[6],
+                                         kind: val[2],
                                          annotations: val[0],
                                          location: location,
                                          comment: leading_comment(val[0].first&.location || location))
       }
-    | annotations kATTRWRITER keyword type {
-        location = val[1].location + val[3].location
-        result = Members::AttrWriter.new(name: val[2].value,
+    | annotations kATTRWRITER attribute_kind keyword type {
+        location = val[1].location + val[4].location
+        result = Members::AttrWriter.new(name: val[3].value,
                                          ivar_name: nil,
-                                         type: val[3],
+                                         kind: val[2],
+                                         type: val[4],
                                          annotations: val[0],
                                          location: location,
                                          comment: leading_comment(val[0].first&.location || location))
       }
-    | annotations kATTRWRITER method_name attr_var_opt kCOLON type {
-        location = val[1].location + val[5].location
-        result = Members::AttrWriter.new(name: val[2].value.to_sym,
-                                         ivar_name: val[3],
-                                         type: val[5],
+    | annotations kATTRWRITER attribute_kind method_name attr_var_opt kCOLON type {
+        location = val[1].location + val[6].location
+        result = Members::AttrWriter.new(name: val[3].value.to_sym,
+                                         ivar_name: val[4],
+                                         kind: val[2],
+                                         type: val[6],
                                          annotations: val[0],
                                          location: location,
                                          comment: leading_comment(val[0].first&.location || location))
       }
-    | annotations kATTRACCESSOR keyword type {
-        location = val[1].location + val[3].location
-        result = Members::AttrAccessor.new(name: val[2].value,
+    | annotations kATTRACCESSOR attribute_kind keyword type {
+        location = val[1].location + val[4].location
+        result = Members::AttrAccessor.new(name: val[3].value,
                                            ivar_name: nil,
-                                           type: val[3],
+                                           kind: val[2],
+                                           type: val[4],
                                            annotations: val[0],
                                            location: location,
                                            comment: leading_comment(val[0].first&.location || location))
       }
-    | annotations kATTRACCESSOR method_name attr_var_opt kCOLON type {
-        location = val[1].location + val[5].location
-        result = Members::AttrAccessor.new(name: val[2].value.to_sym,
-                                           ivar_name: val[3],
-                                           type: val[5],
+    | annotations kATTRACCESSOR attribute_kind method_name attr_var_opt kCOLON type {
+        location = val[1].location + val[6].location
+        result = Members::AttrAccessor.new(name: val[3].value.to_sym,
+                                           ivar_name: val[4],
+                                           kind: val[2],
+                                           type: val[6],
                                            annotations: val[0],
                                            location: location,
                                            comment: leading_comment(val[0].first&.location || location))
@@ -474,26 +467,13 @@ rule
       }
 
   method_type:
-      start_merged_scope type_params params_opt block_opt kARROW simple_type {
+      start_merged_scope type_params proc_type {
         reset_variable_scope
 
-        location = (val[1] || val[2] || val[3] || val[4]).location + val[5].location
+        location = (val[1] || val[2]).location + val[2].location
         type_params = val[1]&.value || []
 
-        params = val[2]&.value || empty_params_result
-
-        type = Types::Function.new(
-          required_positionals: params[0],
-          optional_positionals: params[1],
-          rest_positionals: params[2],
-          trailing_positionals: params[3],
-          required_keywords: params[4],
-          optional_keywords: params[5],
-          rest_keywords: params[6],
-          return_type: val[5]
-        )
-
-        block = val[3]&.value
+        type, block = val[2].value
 
         result = MethodType.new(type_params: type_params,
                                 type: type,
@@ -507,14 +487,13 @@ rule
         result = LocatedValue.new(value: val[1], location: val[0].location + val[2].location)
       }
 
-  block_opt:
-      { result = nil }
-    | kLBRACE function_type kRBRACE {
-        block = MethodType::Block.new(type: val[1].value, required: true)
+  block:
+      kLBRACE simple_function_type kRBRACE {
+        block = Types::Block.new(type: val[1].value, required: true)
         result = LocatedValue.new(value: block, location: val[0].location + val[2].location)
       }
-    | kQUESTION kLBRACE function_type kRBRACE {
-        block = MethodType::Block.new(type: val[2].value, required: false)
+    | kQUESTION kLBRACE simple_function_type kRBRACE {
+        block = Types::Block.new(type: val[2].value, required: false)
         result = LocatedValue.new(value: block, location: val[0].location + val[3].location)
       }
 
@@ -797,8 +776,9 @@ rule
         result = Types::ClassSingleton.new(name: val[2].value,
                                            location: val[0].location + val[3].location)
       }
-    | kHAT function_type {
-        result = Types::Proc.new(type: val[1].value, location: val[0].location + val[1].location)
+    | kHAT proc_type {
+        type, block = val[1].value
+        result = Types::Proc.new(type: type, block: block, location: val[0].location + val[1].location)
       }
     | simple_type kQUESTION {
         result = Types::Optional.new(type: val[0], location: val[0].location + val[1].location)
@@ -842,6 +822,15 @@ rule
     | keyword type {
         result = { val[0].value => val[1] }
       }
+    | identifier_keywords kCOLON type {
+        result = { val[0].value => val[2] }
+      }
+    | tQUOTEDIDENT kCOLON type {
+        result = { val[0].value => val[2] }
+      }
+    | tQUOTEDMETHOD kCOLON type {
+        result = { val[0].value => val[2] }
+      }
 
   keyword_name:
       keyword
@@ -851,7 +840,32 @@ rule
 
   keyword: tLKEYWORD | tUKEYWORD | tLKEYWORD_Q_E | tUKEYWORD_Q_E
 
-  function_type:
+  proc_type:
+      params_opt block kARROW simple_type {
+        location = (val[0] || val[1] || val[2]).location + val[3].location
+
+        params = val[0]&.value || [[], [], nil, [], {}, {}, nil]
+
+        type = Types::Function.new(
+          required_positionals: params[0],
+          optional_positionals: params[1],
+          rest_positionals: params[2],
+          trailing_positionals: params[3],
+          required_keywords: params[4],
+          optional_keywords: params[5],
+          rest_keywords: params[6],
+          return_type: val[3]
+        )
+
+        block = val[1].value
+
+        result = LocatedValue.new(value: [type, block], location: location)
+      }
+    | simple_function_type {
+        result = LocatedValue.new(value: [val[0].value, nil], location: val[0].location)
+      }
+
+  simple_function_type:
       kLPAREN params kRPAREN kARROW simple_type {
         location = val[0].location + val[4].location
         type = Types::Function.new(
@@ -883,7 +897,7 @@ rule
         result = LocatedValue.new(value: type, location: location)
       }
 
-    params:
+  params:
       required_positional kCOMMA params {
         result = val[2]
         result[0].unshift(val[0])
@@ -1294,6 +1308,10 @@ ANNOTATION_RE = Regexp.union(/%a\{.*?\}/,
                              /%a\(.*?\)/,
                              /%a\<.*?\>/,
                              /%a\|.*?\|/)
+
+escape_sequences = %w[a b e f n r s t v "].map { |l| "\\\\#{l}" }
+DBL_QUOTE_STR_ESCAPE_SEQUENCES_RE = /(#{escape_sequences.join("|")})/
+
 def next_token
   if @type
     type = @type
@@ -1373,7 +1391,21 @@ def next_token
   when input.scan(/[a-z_]\w*\b/)
     new_token(:tLIDENT)
   when input.scan(/"(\\"|[^"])*"/)
-    s = input.matched.yield_self {|s| s[1, s.length - 2] }.gsub(/\\"/, '"')
+    s = input.matched.yield_self {|s| s[1, s.length - 2] }
+                     .gsub(DBL_QUOTE_STR_ESCAPE_SEQUENCES_RE) do |match|
+                       case match
+                       when '\\a' then "\a"
+                       when '\\b' then "\b"
+                       when '\\e' then "\e"
+                       when '\\f' then "\f"
+                       when '\\n' then "\n"
+                       when '\\r' then "\r"
+                       when '\\s' then "\s"
+                       when '\\t' then "\t"
+                       when '\\v' then "\v"
+                       when '\\"' then '"'
+                       end
+                     end
     new_token(:tSTRING, s)
   when input.scan(/'(\\'|[^'])*'/)
     s = input.matched.yield_self {|s| s[1, s.length - 2] }.gsub(/\\'/, "'")

data/lib/rbs/prototype/rb.rb

@@ -15,6 +15,14 @@ module RBS
             :instance
           end
         end
+
+        def attribute_kind
+          if singleton
+            :singleton
+          else
+            :instance
+          end
+        end
       end
 
       attr_reader :source_decls
@@ -77,7 +85,7 @@ module RBS
           class_name, super_class, *class_body = node.children
           kls = AST::Declarations::Class.new(
             name: const_to_name(class_name),
-            super_class: super_class && AST::Declarations::Class::Super.new(name: const_to_name(super_class), args: []),
+            super_class: super_class && AST::Declarations::Class::Super.new(name: const_to_name(super_class), args: [], location: nil),
             type_params: AST::Declarations::ModuleTypeParams.empty,
             members: [],
             annotations: [],
@@ -121,9 +129,13 @@ module RBS
             RBS.logger.warn "`class <<` syntax with not-self may be compiled to incorrect code: #{this}"
           end
 
+          accessibility = current_accessibility(decls)
+
           ctx = Context.initial.tap { |ctx| ctx.singleton = true }
           process_children(body, decls: decls, comments: comments, context: ctx)
 
+          decls << accessibility
+
         when :DEFN, :DEFS
             if node.type == :DEFN
               def_name, def_body = node.children
@@ -202,6 +214,7 @@ module RBS
                   name: name,
                   ivar_name: nil,
                   type: Types::Bases::Any.new(location: nil),
+                  kind: context.attribute_kind,
                   location: nil,
                   comment: comments[node.first_lineno - 1],
                   annotations: []
@@ -215,6 +228,7 @@ module RBS
                   name: name,
                   ivar_name: nil,
                   type: Types::Bases::Any.new(location: nil),
+                  kind: context.attribute_kind,
                   location: nil,
                   comment: comments[node.first_lineno - 1],
                   annotations: []
@@ -228,6 +242,7 @@ module RBS
                   name: name,
                   ivar_name: nil,
                   type: Types::Bases::Any.new(location: nil),
+                  kind: context.attribute_kind,
                   location: nil,
                   comment: comments[node.first_lineno - 1],
                   annotations: []
@@ -549,7 +564,7 @@ module RBS
         method_block = nil
 
         if block
-          method_block = MethodType::Block.new(
+          method_block = Types::Block.new(
             required: true,
             type: Types::Function.empty(untyped)
           )
@@ -557,7 +572,7 @@ module RBS
 
         if body_node
           if (yields = any_node?(body_node) {|n| n.type == :YIELD })
-            method_block = MethodType::Block.new(
+            method_block = Types::Block.new(
               required: true,
               type: Types::Function.empty(untyped)
             )

data/lib/rbs/prototype/rbi.rb

@@ -47,7 +47,7 @@ module RBS
       def push_class(name, super_class, comment:)
         modules.push AST::Declarations::Class.new(
           name: nested_name(name),
-          super_class: super_class && AST::Declarations::Class::Super.new(name: const_to_name(super_class), args: []),
+          super_class: super_class && AST::Declarations::Class::Super.new(name: const_to_name(super_class), args: [], location: nil),
           type_params: AST::Declarations::ModuleTypeParams.empty,
           members: [],
           annotations: [],
@@ -387,19 +387,19 @@ module RBS
         if block
           if (type = vars[block])
             if type.is_a?(Types::Proc)
-              method_block = MethodType::Block.new(required: true, type: type.type)
+              method_block = Types::Block.new(required: true, type: type.type)
             elsif type.is_a?(Types::Bases::Any)
-              method_block = MethodType::Block.new(
+              method_block = Types::Block.new(
                 required: true,
                 type: Types::Function.empty(Types::Bases::Any.new(location: nil))
               )
             # Handle an optional block like `T.nilable(T.proc.void)`.
             elsif type.is_a?(Types::Optional) && type.type.is_a?(Types::Proc)
-              method_block = MethodType::Block.new(required: false, type: type.type.type)
+              method_block = Types::Block.new(required: false, type: type.type.type)
             else
               STDERR.puts "Unexpected block type: #{type}"
               PP.pp args_node, STDERR
-              method_block = MethodType::Block.new(
+              method_block = Types::Block.new(
                 required: true,
                 type: Types::Function.empty(Types::Bases::Any.new(location: nil))
               )
@@ -485,7 +485,7 @@ module RBS
           Types::Tuple.new(types: types, location: nil)
         else
           if proc_type?(type_node)
-            Types::Proc.new(type: method_type(nil, type_node, variables: variables).type, location: nil)
+            Types::Proc.new(type: method_type(nil, type_node, variables: variables).type, block: nil, location: nil)
           else
             STDERR.puts "Unexpected type_node:"
             PP.pp type_node, STDERR

data/lib/rbs/prototype/runtime.rb

@@ -61,11 +61,32 @@ module RBS
         end
       end
 
-      def each_mixin(mixins, *super_mixes)
-        supers = Set.new(super_mixes)
-        mixins.each do |mix|
+      def each_included_module(type_name, mod)
+        supers = Set[]
+
+        mod.included_modules.each do |mix|
+          supers.merge(mix.included_modules)
+        end
+
+        if mod.is_a?(Class)
+          mod.superclass.included_modules.each do |mix|
+            supers << mix
+            supers.merge(mix.included_modules)
+          end
+        end
+
+        mod.included_modules.each do |mix|
           unless supers.include?(mix)
-            yield mix
+            unless const_name(mix)
+              RBS.logger.warn("Skipping anonymous module #{mix} included in #{mod}")
+            else
+              module_name = module_full_name = to_type_name(const_name(mix))
+              if module_full_name.namespace == type_name.namespace
+                module_name = TypeName.new(name: module_full_name.name, namespace: Namespace.empty)
+              end
+
+              yield module_name, module_full_name, mix
+            end
           end
         end
       end
@@ -103,7 +124,7 @@ module RBS
           when :keyrest
             rest_keywords = Types::Function::Param.new(name: nil, type: untyped)
           when :block
-            block = MethodType::Block.new(
+            block = Types::Block.new(
               type: Types::Function.empty(untyped).update(rest_positionals: Types::Function::Param.new(name: nil, type: untyped)),
               required: true
             )
@@ -298,11 +319,13 @@ module RBS
                      location: nil
                    )
                  else
-                   Types::ClassInstance.new(name: to_type_name(value.class.to_s), args: [], location: nil)
+                   value_type_name = to_type_name(const_name(value.class))
+                   args = type_args(value_type_name)
+                   Types::ClassInstance.new(name: value_type_name, args: args, location: nil)
                  end
 
           @decls << AST::Declarations::Constant.new(
-            name: "#{mod.to_s}::#{name}",
+            name: "#{const_name(mod)}::#{name}",
             type: type,
             location: nil,
             comment: nil
@@ -311,14 +334,16 @@ module RBS
       end
 
       def generate_class(mod)
-        type_name = to_type_name(mod.name)
+        type_name = to_type_name(const_name(mod))
         super_class = if mod.superclass == ::Object
                         nil
-                      elsif mod.superclass.name.nil?
+                      elsif const_name(mod.superclass).nil?
                         RBS.logger.warn("Skipping anonymous superclass #{mod.superclass} of #{mod}")
                         nil
                       else
-                        AST::Declarations::Class::Super.new(name: to_type_name(mod.superclass.name), args: [])
+                        super_name = to_type_name(const_name(mod.superclass))
+                        super_args = type_args(super_name)
+                        AST::Declarations::Class::Super.new(name: super_name, args: super_args, location: nil)
                       end
 
         decl = AST::Declarations::Class.new(
@@ -331,20 +356,22 @@ module RBS
           comment: nil
         )
 
-        each_mixin(mod.included_modules, *mod.superclass.included_modules, *mod.included_modules.flat_map(&:included_modules)) do |included_module|
-          unless included_module.name
-            RBS.logger.warn("Skipping anonymous module #{included_module} included in #{mod}")
-            next
-          end
-
-          module_name = to_type_name(included_module.name)
-          if module_name.namespace == type_name.namespace
-            module_name = TypeName.new(name: module_name.name, namespace: Namespace.empty)
-          end
-
+        each_included_module(type_name, mod) do |module_name, module_full_name, _|
+          args = type_args(module_full_name)
           decl.members << AST::Members::Include.new(
             name: module_name,
-            args: [],
+            args: args,
+            location: nil,
+            comment: nil,
+            annotations: []
+          )
+        end
+
+        each_included_module(type_name, mod.singleton_class) do |module_name, module_full_name ,_|
+          args = type_args(module_full_name)
+          decl.members << AST::Members::Extend.new(
+            name: module_name,
+            args: args,
             location: nil,
             comment: nil,
             annotations: []
@@ -378,21 +405,22 @@ module RBS
           comment: nil
         )
 
-        each_mixin(mod.included_modules, *mod.included_modules.flat_map(&:included_modules), namespace: type_name.namespace) do |included_module|
-          included_module_name = const_name(included_module)
-          unless included_module_name
-            RBS.logger.warn("Skipping anonymous module #{included_module} included in #{mod}")
-            next
-          end
-
-          module_name = to_type_name(included_module_name)
-          if module_name.namespace == type_name.namespace
-            module_name = TypeName.new(name: module_name.name, namespace: Namespace.empty)
-          end
-
+        each_included_module(type_name, mod) do |module_name, module_full_name, _|
+          args = type_args(module_full_name)
           decl.members << AST::Members::Include.new(
             name: module_name,
-            args: [],
+            args: args,
+            location: nil,
+            comment: nil,
+            annotations: []
+          )
+        end
+
+        each_included_module(type_name, mod.singleton_class) do |module_name, module_full_name, _|
+          args = type_args(module_full_name)
+          decl.members << AST::Members::Extend.new(
+            name: module_name,
+            args: args,
             location: nil,
             comment: nil,
             annotations: []
@@ -410,6 +438,14 @@ module RBS
         @module_name_method ||= Module.instance_method(:name)
         @module_name_method.bind(const).call
       end
+
+      def type_args(type_name)
+        if class_decl = env.class_decls[type_name.absolute!]
+          class_decl.type_params.size.times.map { :untyped }
+        else
+          []
+        end
+      end
     end
   end
 end