rbs 0.10.0 → 0.13.0

data/lib/rbs/variance_calculator.rb

@@ -73,11 +73,11 @@ module RBS
         type(param.type, result: result, context: :contravariant)
       end
 
-      if method_type.block
-        method_type.block.type.each_param do |param|
+      if block = method_type.block
+        block.type.each_param do |param|
           type(param.type, result: result, context: :covariant)
         end
-        type(method_type.block.type.return_type, result: result, context: :contravariant)
+        type(block.type.return_type, result: result, context: :contravariant)
       end
 
       type(method_type.type.return_type, result: result, context: :covariant)
@@ -113,19 +113,20 @@ module RBS
 
         type_params = case type
                       when Types::ClassInstance
-                        env.class_decls[type.name]&.type_params
+                        env.class_decls[type.name].type_params
                       when Types::Interface
-                        env.interface_decls[type.name]&.decl&.type_params
+                        env.interface_decls[type.name].decl.type_params
                       end
 
         type.args.each.with_index do |ty, i|
           var = type_params.params[i]
-          case var.variance
+          case var&.variance
           when :invariant
             type(ty, result: result, context: :invariant)
           when :covariant
             type(ty, result: result, context: context)
           when :contravariant
+            # @type var con: variance
             con = case context
                   when :invariant
                     :invariant
@@ -133,6 +134,8 @@ module RBS
                     :contravariant
                   when :contravariant
                     :covariant
+                  else
+                    raise                    
                   end
             type(ty, result: result, context: con)
           end

data/lib/rbs/version.rb

@@ -1,3 +1,3 @@
 module RBS
-  VERSION = "0.10.0"
+  VERSION = "0.13.0"
 end

data/lib/rbs/writer.rb

@@ -60,6 +60,8 @@ module RBS
 
     def write(decls)
       [nil, *decls].each_cons(2) do |prev, decl|
+        raise unless decl
+
         preserve_empty_line(prev, decl)
         write_decl decl
       end
@@ -68,8 +70,8 @@ module RBS
     def write_decl(decl)
       case decl
       when AST::Declarations::Class
-        super_class = if decl.super_class
-                        " < #{name_and_args(decl.super_class.name, decl.super_class.args)}"
+        super_class = if super_class = decl.super_class
+                        " < #{name_and_args(super_class.name, super_class.args)}"
                       end
         write_comment decl.comment
         write_annotation decl.annotations
@@ -77,6 +79,8 @@ module RBS
 
         indent do
           [nil, *decl.members].each_cons(2) do |prev, member|
+            raise unless member
+
             preserve_empty_line prev, member
             write_member member
           end
@@ -134,9 +138,6 @@ module RBS
 
         puts "end"
 
-      when AST::Declarations::Extension
-        RBS.logger.warn "Extension is ignored: #{decl.name}"
-
       end
     end
 
@@ -250,8 +251,7 @@ module RBS
 
       string = ""
 
-      attrs = member.attributes.empty? ? "" : member.attributes.join(" ") + " "
-      prefix = "#{attrs}def #{name}:"
+      prefix = "def #{name}:"
       padding = " " * (prefix.size-1)
 
       string << prefix
@@ -289,20 +289,29 @@ module RBS
     end
 
     def preserve_empty_line(prev, decl)
-      return unless prev
+      # @type var decl: _Located
 
-      decl = decl.comment if decl.respond_to?(:comment) && decl.comment
+      return unless prev
 
-      # When the signature is not constructed by the parser,
-      # it always inserts an empty line.
-      if !prev.location || !decl.location
-        puts
-        return
+      if (_ = decl).respond_to?(:comment)
+        if comment = (_ = decl).comment
+          decl = comment
+        end
       end
 
-      prev_end_line = prev.location.end_line
-      start_line = decl.location.start_line
-      if start_line - prev_end_line > 1
+      prev_loc = prev.location
+      decl_loc = decl.location
+
+      if prev_loc && decl_loc
+        prev_end_line = prev_loc.end_line
+        start_line = decl_loc.start_line
+  
+        if start_line - prev_end_line > 1
+          puts
+        end
+      else
+        # When the signature is not constructed by the parser,
+        # it always inserts an empty line.
         puts
       end
     end

data/sig/annotation.rbs

@@ -0,0 +1,26 @@
+module RBS
+  module AST
+    # RBS allows writing annotations of declarations and members.
+    #
+    #    %a{annotation_here}
+    #    class Hello
+    #      %a{rbs:test:skip}
+    #      def foo: () -> void
+    #    end
+    #
+    class Annotation
+      attr_reader string: String
+      attr_reader location: Location?
+
+      def initialize: (string: String, location: Location?) -> void
+
+      def ==: (untyped other) -> bool
+
+      alias eql? ==
+
+      def hash: () -> Integer
+
+      def to_json: (*untyped) -> String
+    end
+  end
+end

data/sig/buffer.rbs

@@ -0,0 +1,28 @@
+module RBS
+  class Buffer
+    # Location in a buffer.
+    # A pair of line number (1 origin) and column number (0 origin).
+    #
+    type loc = [Integer, Integer]
+
+    # Name to identify Buffer.
+    attr_reader name: untyped
+
+    # The content of the buffer.
+    attr_reader content: String
+
+    attr_reader lines: Array[String]
+
+    attr_reader ranges: Array[Range[Integer]]
+
+    def initialize: (name: untyped name, content: String content) -> void
+
+    # Translate position to location.
+    def pos_to_loc: (Integer pos) -> loc
+
+    # Translate location to position.
+    def loc_to_pos: (loc loc) -> Integer
+
+    def last_position: () -> Integer
+  end
+end

data/sig/builtin_names.rbs

@@ -0,0 +1,41 @@
+module RBS
+  module BuiltinNames
+    class Name
+      attr_reader name: TypeName
+
+      def initialize: (name: TypeName) -> void
+
+      def to_s: () -> String
+
+      def instance_type: (*Types::t) -> Types::ClassInstance
+
+      def instance_type?: (Types::t) -> bool
+
+      def singleton_type: () -> Types::ClassSingleton
+
+      def singleton_type?: (Types::t) -> bool
+
+      def self.define: (Symbol, ?namespace: Namespace) -> instance
+    end
+
+    BasicObject: Name
+    Object: Name
+    Kernel: Name
+    String: Name
+    Comparable: Name
+    Enumerable: Name
+    Class: Name
+    Module: Name
+    Array: Name
+    Hash: Name
+    Range: Name
+    Enumerator: Name
+    Set: Name
+    Symbol: Name
+    Integer: Name
+    Float: Name
+    Regexp: Name
+    TrueClass: Name
+    FalseClass: Name
+  end
+end

data/sig/comment.rbs

@@ -0,0 +1,26 @@
+module RBS
+  module AST
+    # RBS allows writing documentation of declarations and members.
+    #
+    #    # This is a doc for class.
+    #    class Hello
+    #    end
+    #
+    class Comment
+      attr_reader string: String
+      attr_reader location: Location?
+
+      def initialize: (string: String, location: Location?) -> void
+
+      def ==: (untyped other) -> bool
+
+      alias eql? ==
+
+      def hash: () -> Integer
+
+      def to_json: (*untyped) -> String
+
+      def concat: (string: String, location: Location?) -> self
+    end
+  end
+end

data/sig/constant.rbs

@@ -0,0 +1,21 @@
+module RBS
+  class Constant
+    type constant_entry = Environment::ClassEntry
+                        | Environment::ModuleEntry
+                        | Environment::SingleEntry[TypeName, AST::Declarations::Constant]
+
+    attr_reader name: TypeName
+
+    attr_reader type: Types::t
+
+    attr_reader entry: constant_entry
+
+    def initialize: (name: TypeName, type: Types::t, entry: constant_entry) -> void
+                  
+    def ==: (untyped other) -> bool
+          
+    alias eql? ==
+
+    def hash: () -> Integer
+  end
+end

data/sig/constant_table.rbs

@@ -0,0 +1,30 @@
+module RBS
+  class ConstantTable
+    attr_reader definition_builder: DefinitionBuilder
+    attr_reader constant_scopes_cache: Hash[TypeName, Array[Namespace]]
+    attr_reader resolver: TypeNameResolver
+    attr_reader env(): Environment
+
+    def initialize: (builder: DefinitionBuilder) -> void
+                  
+    def absolute_type: (Types::t, context: Array[Namespace]) -> Types::t
+                     
+    def absolute_type_name: (TypeName, context: Array[Namespace], location: Location?) -> TypeName
+                          
+    def name_to_constant: (TypeName) -> Constant?
+                        
+    def split_name: (TypeName) -> Array[Symbol]
+                  
+    def resolve_constant_reference: (TypeName name, context: Array[Namespace]) -> Constant?
+                                  
+    def resolve_constant_reference_context: (Symbol, context: Array[Namespace]) -> Constant?
+                                          
+    def resolve_constant_reference_inherit: (Symbol, scopes: Array[Namespace], ?no_object: bool) -> Constant?
+                                          
+    def constant_scopes: (TypeName) -> Array[Namespace]
+                       
+    def constant_scopes_module: (TypeName, scopes: Array[Namespace]) -> Array[Namespace]
+                       
+    def constant_scopes0: (TypeName, ?scopes: Array[Namespace]) -> Array[Namespace]
+  end
+end

data/sig/declarations.rbs

@@ -0,0 +1,202 @@
+module RBS
+  module AST
+    module Declarations
+      type t = Class | Module | Interface | Constant | Global | Alias
+      
+      class Base
+      end
+
+      type variance = :invariant | :covariant | :contravariant
+
+      class ModuleTypeParams
+        class TypeParam
+          attr_reader name: Symbol
+          attr_reader variance: variance
+          attr_reader skip_validation: bool
+
+          def initialize: (name: Symbol, variance: variance, skip_validation: bool) -> void
+
+          include _ToJson
+        end
+
+        attr_reader params: Array[TypeParam]
+
+        def initialize: () -> void
+
+        def add: (TypeParam param) -> self
+
+        include _HashEqual
+        include _ToJson
+
+        def []: (Symbol) -> TypeParam?
+
+        def each: { (TypeParam) -> void } -> void
+                | () -> Enumerator[TypeParam, void]
+
+        def self.empty: () -> instance
+
+        def variance: (Symbol) -> variance
+
+        def skip_validation?: (Symbol) -> bool
+
+        def empty?: () -> bool
+
+        def size: () -> Integer
+
+        def rename_to: (Array[Symbol] names) -> ModuleTypeParams
+      end
+
+      interface _WithMember
+        def members: () -> Array[untyped]
+      end
+
+      module NestedDeclarationHelper : _WithMember
+        def each_member: () { (Members::t) -> void } -> void
+                       | () -> Enumerator[Members::t, void]
+
+        def each_decl: () { (t) -> void } -> void
+                     | () -> Enumerator[t, void]
+      end
+
+      module MixinHelper : _WithMember
+        type mixin_member = Members::Include | Members::Extend | Members::Prepend
+
+        @mixins: Array[mixin_member]
+
+        def each_mixin: () { (mixin_member) -> void } -> void
+                      | () -> Enumerator[mixin_member, void]
+      end
+
+      class Class < Base
+        type member = Members::t | t
+
+        class Super
+          attr_reader name: TypeName
+          attr_reader args: Array[Types::t]
+
+          def initialize: (name: TypeName, args: Array[Types::t]) -> void
+
+          include _HashEqual
+          include _ToJson
+        end
+
+        include NestedDeclarationHelper
+        include MixinHelper
+
+        attr_reader name: TypeName
+        attr_reader type_params: ModuleTypeParams
+        attr_reader members: Array[member]
+        attr_reader super_class: Super?
+        attr_reader annotations: Array[Annotation]
+        attr_reader location: Location?
+        attr_reader comment: Comment?
+
+        def initialize: (name: TypeName, type_params: ModuleTypeParams, members: Array[member], super_class: Super?, annotations: Array[Annotation], location: Location?, comment: Comment?) -> void
+
+        include _HashEqual
+        include _ToJson
+      end
+
+      class Module < Base
+        type member = Members::t | t
+
+        class Self
+          attr_reader name: TypeName
+          attr_reader args: Array[Types::t]
+          attr_reader location: Location?
+
+          def initialize: (name: TypeName, args: Array[Types::t], location: Location?) -> void
+
+          include _HashEqual
+          include _ToJson
+
+          def to_s: () -> String
+        end
+
+        include NestedDeclarationHelper
+        include MixinHelper
+
+        attr_reader name: TypeName
+        attr_reader type_params: ModuleTypeParams
+        attr_reader members: Array[member]
+        attr_reader location: Location?
+        attr_reader annotations: Array[Annotation]
+        attr_reader self_types: Array[Self]
+        attr_reader comment: Comment?
+
+        def initialize: (name: TypeName, type_params: ModuleTypeParams, members: Array[member], location: Location?, annotations: Array[Annotation], self_types: Array[Self], comment: Comment?) -> void
+
+        include _HashEqual
+        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
+
+        attr_reader name: TypeName
+        attr_reader type_params: ModuleTypeParams
+        attr_reader members: Array[member]
+        attr_reader annotations: Array[Annotation]
+        attr_reader location: Location?
+        attr_reader comment: Comment?
+
+        def initialize: (name: TypeName, type_params: ModuleTypeParams, members: Array[member], annotations: Array[Annotation], location: Location?, comment: Comment?) -> void
+
+        include _HashEqual
+        include _ToJson
+      end
+
+      class Alias < Base
+        attr_reader name: TypeName
+        attr_reader type: Types::t
+        attr_reader annotations: Array[Annotation]
+        attr_reader location: Location?
+        attr_reader comment: Comment?
+
+        def initialize: (name: TypeName, type: Types::t, annotations: Array[Annotation], location: Location?, comment: Comment?) -> void
+
+        include _HashEqual
+        include _ToJson
+      end
+
+      class Constant < Base
+        attr_reader name: TypeName
+        attr_reader type: Types::t
+        attr_reader location: Location?
+        attr_reader comment: Comment?
+
+        def initialize: (name: TypeName, type: Types::t, location: Location?, comment: Comment?) -> void
+
+        include _HashEqual
+        include _ToJson
+      end
+
+      class Global < Base
+        attr_reader name: Symbol
+        attr_reader type: Types::t
+        attr_reader location: Location?
+        attr_reader comment: Comment?
+
+        def initialize: (name: Symbol, type: Types::t, location: Location?, comment: Comment?) -> void
+
+        include _HashEqual
+        include _ToJson
+      end
+    end
+  end
+end