rbs 1.0.0.pre → 1.0.0.pre2

data/lib/rbs/parser.y

@@ -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

data/lib/rbs/prototype/rb.rb

@@ -129,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

data/lib/rbs/prototype/runtime.rb

@@ -80,12 +80,12 @@ module RBS
             unless const_name(mix)
               RBS.logger.warn("Skipping anonymous module #{mix} included in #{mod}")
             else
-              module_name = to_type_name(const_name(mix))
-              if module_name.namespace == type_name.namespace
-                module_name = TypeName.new(name: module_name.name, namespace: Namespace.empty)
+              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, mix
+              yield module_name, module_full_name, mix
             end
           end
         end
@@ -319,7 +319,9 @@ module RBS
                      location: nil
                    )
                  else
-                   Types::ClassInstance.new(name: to_type_name(const_name(value.class)), 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(
@@ -339,7 +341,9 @@ module RBS
                         RBS.logger.warn("Skipping anonymous superclass #{mod.superclass} of #{mod}")
                         nil
                       else
-                        AST::Declarations::Class::Super.new(name: to_type_name(const_name(mod.superclass)), args: [], location: nil)
+                        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(
@@ -352,20 +356,22 @@ module RBS
           comment: nil
         )
 
-        each_included_module(type_name, mod) do |module_name, _|
+        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, _|
+        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: args,
             location: nil,
             comment: nil,
             annotations: []
@@ -399,20 +405,22 @@ module RBS
           comment: nil
         )
 
-        each_included_module(type_name, mod) do |module_name, _|
+        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, _|
+        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: args,
             location: nil,
             comment: nil,
             annotations: []
@@ -430,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

data/lib/rbs/test/hook.rb

@@ -71,14 +71,15 @@ module RBS
         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}"]
+        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) ..."
+          "Generating method definition: def #{with_name}(#{param_source.join(", ")}, &#{block_param}) ..."
         }
 
         [__LINE__ + 1, <<RUBY]
-def #{with_name}(#{param_source.join(", ")}, &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(", ") + "]" }
 
@@ -88,7 +89,7 @@ def #{with_name}(#{param_source.join(", ")}, &block)
 
     if block_given?
       receiver = self
-      block_receives_block = block.parameters.last&.yield_self {|type, _| type == :block }
+      block_receives_block = #{block_param}.parameters.last&.yield_self {|type, _| type == :block }
 
       wrapped_block = proc do |*block_args, &block2|
         return_from_block = false
@@ -96,12 +97,12 @@ def #{with_name}(#{param_source.join(", ")}, &block)
         begin
           block_result = if receiver.equal?(self)
                            if block_receives_block
-                             block.call(*block_args, &block2)
+                             #{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

data/lib/rbs/types.rb

@@ -943,7 +943,11 @@ 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
 
@@ -953,7 +957,7 @@ module RBS
 
       def initialize(type:, required:)
         @type = type
-        @required = required
+        @required = required ? true : false
       end
 
       def ==(other)

data/lib/rbs/version.rb

@@ -1,3 +1,3 @@
 module RBS
-  VERSION = "1.0.0.pre"
+  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
 

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

data/sig/definition_builder.rbs

@@ -1,100 +1,45 @@
 module RBS
   class DefinitionBuilder
-    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 prepended_modules: Array[Definition::Ancestor::Instance]?
-      attr_reader extended_modules: 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]?,
-               prepended_modules: Array[Definition::Ancestor::Instance]?,
-                extended_modules: 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
-    end
-
     attr_reader env: Environment
     attr_reader type_name_resolver: TypeNameResolver
+    attr_reader ancestor_builder: AncestorBuilder
+    attr_reader method_builder: MethodBuilder
 
     attr_reader instance_cache: Hash[TypeName, Definition | false | nil]
     attr_reader singleton_cache: Hash[TypeName, Definition | false | nil]
+    attr_reader singleton0_cache: Hash[TypeName, Definition | false | nil]
     attr_reader interface_cache: Hash[TypeName, Definition | false | nil]
 
-    attr_reader one_instance_cache: Hash[TypeName, Definition]
-    attr_reader one_singleton_cache: Hash[TypeName, Definition]
-
-    attr_reader instance_ancestors_cache: Hash[TypeName, Definition::InstanceAncestors]
-    attr_reader singleton_ancestor_cache: Hash[TypeName, Definition::SingletonAncestors]
-
-    attr_reader one_instance_ancestors_cache: Hash[TypeName, OneAncestors]
-    attr_reader one_singleton_ancestors_cache: Hash[TypeName, OneAncestors]
-
     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 instance_ancestors: (TypeName, ?building_ancestors: Array[Definition::Ancestor::t]) -> Definition::InstanceAncestors
-
-    def singleton_ancestors: (TypeName, ?building_ancestors: Array[Definition::Ancestor::t]) -> Definition::SingletonAncestors
-
-    def mixin_ancestors: (Environment::ClassEntry | Environment::ModuleEntry, included_modules: Array[Definition::Ancestor::Instance]?, prepended_modules: Array[Definition::Ancestor::Instance]?, extended_modules: Array[Definition::Ancestor::Instance]?) -> void
-
-    def each_member_with_accessibility: (Array[AST::Members::t | AST::Declarations::t], ?accessibility: Definition::accessibility) { (AST::Members::t | AST::Declarations::t, Definition::accessibility) -> void } -> void
-
     def ensure_namespace!: (Namespace, location: Location?) -> void
 
-    def build_singleton: (TypeName) -> Definition
+    def build_interface: (TypeName) -> Definition
 
     def build_instance: (TypeName) -> Definition
 
-    def build_interface: (TypeName) -> Definition
-
-    def build_one_instance: (TypeName) -> Definition
+    def build_singleton0: (TypeName) -> Definition
 
-    def build_one_singleton: (TypeName) -> Definition
+    def build_singleton: (TypeName) -> Definition
 
-    type ancestors = Definition::InstanceAncestors | Definition::SingletonAncestors | nil
-    def merge_definitions: (TypeName,
-                            Array[[Definition::Ancestor::t, Definition]],
-                            entry: Environment::ModuleEntry | Environment::ClassEntry,
-                            self_type: Definition::self_type,
-                            ancestors: ancestors) -> Definition
+    def merge_definition: (src: Definition, dest: Definition, subst: Substitution, ?implemented_in: :keep | TypeName | nil, ?keep_super: bool) -> void
 
-    type method_kind = :instance | :singleton
-    def merge_method: (TypeName, Hash[Symbol, Definition::Method], Symbol, Definition::Method, Substitution, kind: method_kind) -> void
+    def merge_method: (TypeName, Hash[Symbol, Definition::Method], Symbol, Definition::Method, Substitution, ?implemented_in: :keep | TypeName | nil, ?keep_super: bool) -> void
 
-    def merge_variable: (Hash[Symbol, Definition::Variable], Symbol, Definition::Variable) -> void
+    def merge_variable: (Hash[Symbol, Definition::Variable], Symbol, Definition::Variable, Substitution, ?keep_super: bool) -> void
 
     def try_cache: (TypeName, cache: Hash[TypeName, Definition | false | nil]) { () -> Definition } -> Definition
 
-    type member_detail = [Definition::accessibility, Definition::Method?, AST::Members::MethodDefinition?, Array[AST::Members::MethodDefinition]]
-    def method_definition_members: (TypeName, Environment::ClassEntry | Environment::ModuleEntry, kind: :singleton | :instance) -> Hash[Symbol, member_detail]
-
     def validate_params_with: (AST::Declarations::ModuleTypeParams, result: VarianceCalculator::Result) { (AST::Declarations::ModuleTypeParams::TypeParam) -> void } -> void
 
-    def validate_parameter_variance: (decl: AST::Declarations::Class | AST::Declarations::Module | AST::Declarations::Interface, methods: Hash[Symbol, Definition::Method]) -> void
+    def validate_type_params: (Definition, ancestors: AncestorBuilder::OneAncestors, methods: MethodBuilder::Methods) -> void
+
+    def source_location: (Definition::Ancestor::Instance::source, AST::Declarations::t) -> Location?
 
-    def expand_alias: (TypeName) -> Types::t
+    def insert_variable: (TypeName, Hash[Symbol, Definition::Variable], name: Symbol, type: Types::t) -> void
 
-    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
+    def define_methods: (Definition, interface_methods: Hash[Symbol, Definition::Method], methods: MethodBuilder::Methods, super_interface_method: bool) -> void
   end
 end