rbs 0.11.0 → 0.12.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,9 +113,9 @@ 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|
@@ -126,6 +126,7 @@ module RBS
           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.11.0"
+  VERSION = "0.12.0"
 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/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

data/sig/definition.rbs

@@ -0,0 +1,129 @@
+module RBS
+  class Definition
+    type accessibility = :public | :private
+
+    class Variable
+      attr_reader parent_variable: Variable?
+      attr_reader type: Types::t
+      attr_reader declared_in: TypeName
+
+      def initialize: (parent_variable: Variable?, type: Types::t, declared_in: TypeName) -> void
+
+      def sub: (Substitution) -> Variable
+    end
+
+    class Method
+      type method_member = AST::Members::MethodDefinition | AST::Members::AttrReader | AST::Members::AttrAccessor | AST::Members::AttrWriter
+
+      class TypeDef
+        attr_reader type: MethodType
+        attr_reader member: method_member
+        attr_reader defined_in: TypeName?
+        attr_reader implemented_in: TypeName?
+
+        def initialize: (type: MethodType, member: method_member, defined_in: TypeName?, implemented_in: TypeName?) -> void
+
+        def comment: () -> AST::Comment?
+
+        def annotations: () -> Array[AST::Annotation]
+
+        def update: (?type: MethodType, ?member: method_member, ?defined_in: TypeName?, ?implemented_in: TypeName?) -> TypeDef
+        
+        def overload?: () -> bool
+      end
+
+      attr_reader super_method: Method?
+      attr_reader defs: Array[TypeDef]
+      attr_reader accessibility: accessibility
+      attr_reader extra_annotations: Array[AST::Annotation]
+      attr_reader defined_in: TypeName?
+      attr_reader implemented_in: TypeName?
+      attr_reader method_types: Array[MethodType]
+      attr_reader comments: Array[AST::Comment]
+      attr_reader annotations: Array[AST::Annotation]
+      attr_reader members: Array[method_member]
+
+      def initialize: (super_method: Method?, defs: Array[TypeDef], accessibility: accessibility, ?annotations: Array[AST::Annotation]) -> void
+
+      def public?: () -> bool
+
+      def private?: () -> bool
+
+      def sub: (Substitution) -> Method
+
+      def map_type: () { (Types::t) -> Types::t } -> Method
+
+      def map_method_type: () { (MethodType) -> MethodType } -> Method
+    end
+
+    module Ancestor
+      type t = Instance | Singleton
+
+      class Instance
+        attr_reader name: TypeName
+        attr_reader args: Array[Types::t]
+
+        def initialize: (name: TypeName, args: Array[Types::t]) -> void
+      end
+
+      class Singleton
+        attr_reader name: TypeName
+
+        def initialize: (name: TypeName) -> void
+      end
+    end
+
+    class InstanceAncestors
+      attr_reader type_name: TypeName
+      attr_reader params: Array[Symbol]
+      attr_reader ancestors: Array[Ancestor::t]
+
+      def initialize: (type_name: TypeName, params: Array[Symbol], ancestors: Array[Ancestor::t]) -> void
+
+      def apply: (Array[Types::t], location: Location?) -> Array[Ancestor::t]
+    end
+
+    class SingletonAncestors
+      attr_reader type_name: TypeName
+      attr_reader ancestors: Array[Ancestor::t]
+
+      def initialize: (type_name: TypeName, ancestors: Array[Ancestor::t]) -> void
+    end
+
+    type self_type = Types::ClassSingleton | Types::ClassInstance | Types::Interface
+    type definition_entry = Environment::ModuleEntry | Environment::ClassEntry | Environment::SingleEntry[TypeName, AST::Declarations::Interface]
+
+    attr_reader type_name: TypeName
+    attr_reader entry: definition_entry
+    attr_reader ancestors: InstanceAncestors | SingletonAncestors | nil
+    attr_reader self_type: self_type
+    attr_reader methods: Hash[Symbol, Method]
+    attr_reader instance_variables: Hash[Symbol, Variable]
+    attr_reader class_variables: Hash[Symbol, Variable]
+
+    def initialize: (type_name: TypeName, entry: definition_entry, self_type: self_type, ancestors: InstanceAncestors | SingletonAncestors | nil) -> void
+
+    def class?: () -> bool
+
+    def module?: () -> bool
+
+    def interface?: () -> bool
+
+    def class_type?: () -> bool
+
+    def instance_type?: () -> bool
+
+    def interface_type?: () -> bool
+
+    def type_params: () -> Array[Symbol]
+
+    def type_params_decl: () -> AST::Declarations::ModuleTypeParams
+
+    def sub: (Substitution) -> Definition
+
+    def map_method_type: () { (MethodType) -> MethodType } -> Definition
+
+    def each_type: () { (Types::t) -> void } -> void
+                 | () -> Enumerator[Types::t, void]
+  end
+end