rbs 4.1.0.pre.2-java

data/sig/typename.rbs

@@ -0,0 +1,89 @@
+module RBS
+  # TypeName represents name of types in RBS.
+  #
+  # TypeNames are one of the three kind, class, alias, and interface.
+  # *class* type names corresponds to Ruby classes and modules.
+  # There are no corresponding Ruby value to *alias* and *interface* type names.
+  #
+  class TypeName
+    # Type of type names.
+    #
+    type kind = :class | :alias | :interface
+
+    # The namespace the type name is defined in.
+    attr_reader namespace: Namespace
+
+    # Name of type name.
+    attr_reader name: Symbol
+
+    # Kind of the type.
+    attr_reader kind: kind
+
+    # Initializer accepts two keyword args, `namespace` and `name`.
+    # Note that `kind` is automatically determined from its `name`.
+    #
+    # If the name starts with capital alphabet, it is _class_.
+    # If the name starts with lower case alphabet, it is _alias_.
+    # If the name starts with an underscore, it is _interface_.
+    #
+    def initialize: (namespace: Namespace, name: Symbol) -> void
+
+    @hash: Integer?
+
+    self.@intern_mutex: Mutex
+
+    # Two-level Hash keyed by canonical Namespace identity (outer uses
+    # `compare_by_identity`) and name Symbol.
+    self.@intern_cache: Hash[Namespace, Hash[Symbol, TypeName]]
+
+    # Returns an interned `TypeName` instance.
+    #
+    # The given `namespace` is canonicalized so cached instances always hold an
+    # interned namespace. Subsequent calls with structurally equal arguments
+    # return the same object.
+    def self.[]: (Namespace namespace, Symbol name) -> TypeName
+
+    def ==: (untyped other) -> bool
+
+    def hash: () -> Integer
+
+    def to_s: () -> ::String
+
+    include _ToJson
+
+    # Returns a namespace with same components of self.
+    def to_namespace: () -> Namespace
+
+    # Returns true when self is a _class_ type name.
+    def class?: () -> bool
+
+    # Returns true when self is an _alias_ type name.
+    def alias?: () -> bool
+
+    def absolute!: () -> TypeName
+
+    def absolute?: () -> bool
+
+    def relative!: () -> TypeName
+
+    # Returns true when self is an _interface_ type name.
+    def interface?: () -> bool
+
+    # Returns a new type name with a namespace appended to given namespace.
+    #
+    # ```rb
+    # TypeName.parse("Hello").with_prefix(Namespace("World"))           # => World::Hello
+    # TypeName.parse("Foo::Bar").with_prefix(Namespace("::Hello"))      # => ::Hello::Foo::Bar
+    # TypeName.parse("::A::B").with_prefix(Namespace("C"))              # => ::A::B
+    # ```
+    #
+    def with_prefix: (Namespace namespace) -> TypeName
+
+    def +: (TypeName) -> TypeName
+
+    def split: () -> Array[Symbol]
+
+    # Returns type name with given string representation.
+    def self.parse: (String name) -> RBS::TypeName
+  end
+end

data/sig/types.rbs

@@ -0,0 +1,578 @@
+module RBS
+  module Types
+    # _TypeBase interface represents the operations common to all of the types.
+    #
+    interface _TypeBase
+      # Returns names of free variables of a type.
+      # You can pass a Set instance to add the free variables to the set to avoid Set object allocation.
+      #
+      def free_variables: (?Set[Symbol]) -> Set[Symbol]
+
+      # Receives a substitution and returns a new type applied the substitution.
+      #
+      def sub: (Substitution) -> t
+
+      # Maps type names included in the type and returns new instance of type.
+      def map_type_name: () { (TypeName, Location[untyped, untyped]?, t) -> TypeName } -> t
+
+      # Yields all direct sub types included in the type.
+      # It doesn't yield the type itself.
+      #
+      # ```ruby
+      # parse("Hash[String, Array[Symbol]]").each_type do |ty|
+      #   ...       # Yields String and Array[Symbol]
+      # end
+      # ```
+      #
+      def each_type: () { (t) -> void } -> void
+                   | () -> Enumerator[t, void]
+
+      # Returns a JSON representation.
+      #
+      include _ToJson
+
+      # Returns a String representation.
+      # `level` is used internally.
+      #
+      # ```ruby
+      # parse("String").to_s               # => "String"
+      # parse("String | Integer").to_s()   # => "String | Integer"
+      # parse("String | Integer").to_s(1)  # => "(String | Integer)"
+      # ```
+      #
+      def to_s: (?Integer level) -> String
+
+      # Returns `true` if it has `self` type
+      #
+      def has_self_type?: () -> bool
+
+      # Returns `true` if it has `instance` or `class` types
+      def has_classish_type?: () -> bool
+
+      # Returns `true` if it has `void` types other than *return* position
+      #
+      # * The function return type is a return position (`() -> void`)
+      # * Generic parameter is a return position (`Enumerator[Integer, void]`)
+      #
+      def with_nonreturn_void?: () -> bool
+    end
+
+    # t represents union of all possible types.
+    #
+    type t = Bases::Bool | Bases::Void | Bases::Any | Bases::Nil | Bases::Top | Bases::Bottom | Bases::Self | Bases::Instance | Bases::Class
+           | Variable | ClassSingleton | Interface | ClassInstance | Alias | Tuple | Record | Optional | Union | Intersection | Proc | Literal
+
+    module NoFreeVariables
+      def free_variables: (?Set[Symbol]) -> Set[Symbol]
+    end
+
+    module NoSubst
+      def sub: (Substitution) -> self
+    end
+
+    module EmptyEachType
+      def each_type: () { (t) -> void } -> void
+                   | () -> Enumerator[t, void]
+
+      # `map_type` returns itself, because there is no sub type.
+      #
+      def map_type: () { (t) -> t } -> self
+                  | () -> Enumerator[t, self]
+    end
+
+    module NoTypeName
+      def map_type_name: () { (TypeName, Location[untyped, untyped]?, t) -> TypeName } -> self
+    end
+
+    module Bases
+      class Base
+        include _TypeBase
+
+        attr_reader location: Location[bot, bot]?
+
+        def initialize: (location: Location[bot, bot]?) -> void
+
+        def ==: (untyped other) -> bool
+
+        def hash: () -> Integer
+
+        alias eql? ==
+
+        include NoFreeVariables
+        include NoSubst
+        include EmptyEachType
+        include NoTypeName
+      end
+
+      class Bool < Base
+      end
+
+      class Void < Base
+      end
+
+      class Any < Base
+        @string: String?
+
+        def initialize: (location: Location[bot, bot]?, ?todo: bool) -> void
+      end
+
+      class Nil < Base
+      end
+
+      class Top < Base
+      end
+
+      class Bottom < Base
+      end
+
+      class Self < Base
+      end
+
+      class Instance < Base
+        def sub: (Substitution sub) -> t
+      end
+
+      class Class < Base
+      end
+    end
+
+    class Variable
+      type loc = Location[bot, bot]
+
+      attr_reader name: Symbol
+
+      @@count: Integer
+
+      include _TypeBase
+      include NoTypeName
+      include EmptyEachType
+
+      def initialize: (name: Symbol, location: loc?) -> void
+
+      attr_reader location: loc?
+
+      def ==: (untyped other) -> bool
+
+      alias eql? ==
+
+      def hash: () -> Integer
+
+      def self.build: (Symbol) -> Variable
+                    | (Array[Symbol]) -> Array[Variable]
+
+      # Returns fresh type variable with prefix (if given.)
+      #
+      #     Variable.fresh(:S)       # => S@1
+      #     Variable.fresh(:S)       # => S@2
+      #     Variable.fresh()         # => T@3
+      #
+      def self.fresh: (?Symbol prefix) -> Variable
+    end
+
+    class ClassSingleton
+      # singleton(::Foo)
+      #           ^^^^^  => name
+      type loc = Location[:name, :args]
+
+      def initialize: (name: TypeName, location: loc?, ?args: Array[t]) -> void
+
+      attr_reader location: loc?
+
+      include _TypeBase
+      include Application
+
+      def ==: (untyped other) -> bool
+
+      alias eql? ==
+
+      def hash: () -> Integer
+              
+      def map_type: () { (t) -> t } -> ClassSingleton
+                  | () -> Enumerator[t, ClassSingleton]
+    end
+
+    module Application
+      attr_reader name: TypeName
+      attr_reader args: Array[t]
+
+      def ==: (untyped) -> bool
+
+      alias eql? ==
+
+      def hash: () -> Integer
+
+      def free_variables: (?Set[Symbol]) -> Set[Symbol]
+
+      def to_s: (?Integer level) -> String
+
+      def each_type: () { (t) -> void } -> void
+                   | () -> Enumerator[t, void]
+
+      def has_self_type?: () -> bool
+
+      def has_classish_type?: () -> bool
+
+      def with_nonreturn_void?: () -> bool
+    end
+
+    class Interface
+      # _Foo
+      # ^^^^ => name
+      #
+      # _Foo[Bar, Baz]
+      # ^^^^           => name
+      #     ^^^^^^^^^^ => args
+      type loc = Location[:name, :args]
+
+      def initialize: (name: TypeName, args: Array[t], location: loc?) -> void
+
+      include Application
+      include _TypeBase
+
+      attr_reader location: loc?
+
+      def map_type: () { (t) -> t } -> Interface
+                  | () -> Enumerator[t, Interface]
+    end
+
+    # ClassInstance represents a type of an instance of a class.
+    #
+    #    String           # Type of an instance of String class.
+    #    Array[String]    # Type of an instance of Array class with instances of String.
+    #    Kernel           # Type of an instance of a class which includes Kernel.
+    #
+    class ClassInstance
+      include Application
+
+      # Foo
+      # ^^^ => name
+      #
+      # Foo[Bar, Baz]
+      # ^^^           => name
+      #    ^^^^^^^^^^ => args
+      #
+      type loc = Location[:name, :args]
+
+      def initialize: (name: TypeName, args: Array[t], location: loc?) -> void
+
+      attr_reader location: loc?
+
+      include _TypeBase
+
+      def map_type: () { (t) -> t } -> ClassInstance
+                  | () -> Enumerator[t, ClassInstance]
+    end
+
+    class Alias
+      # foo
+      # ^^^ => name
+      #
+      # foo[bar, baz]
+      # ^^^           => name
+      #    ^^^^^^^^^^ => args
+      #
+      type loc = Location[:name, :args]
+
+      attr_reader location: loc?
+
+      def initialize: (name: TypeName, args: Array[t], location: loc?) -> void
+
+      include _TypeBase
+      include Application
+
+      def map_type: () { (t) -> t } -> Alias
+                  | () -> Enumerator[t, Alias]
+    end
+
+    class Tuple
+      attr_reader types: Array[t]
+
+      type loc = Location[bot, bot]
+
+      def initialize: (types: Array[t], location: loc?) -> void
+
+      include _TypeBase
+
+      attr_reader location: loc?
+
+      def map_type: () { (t) -> t } -> Tuple
+                  | () -> Enumerator[t, Tuple]
+    end
+
+    class Record
+      type key = Symbol | String | Integer | bool
+
+      # All types of all files
+      #
+      # If the key is *required*, the second value of the tuple is `true`.
+      # If the key is *optional*, the second value of the tuple is `false`.
+      #
+      attr_reader all_fields: Hash[key, [t, bool]]
+
+      attr_reader fields: Hash[key, t]
+
+      attr_reader optional_fields: Hash[key, t]
+
+      type loc = Location[bot, bot]
+
+      def initialize: (fields: Hash[key, t], location: loc?) -> void
+                    | (all_fields: Hash[key, [t, bool]], location: loc?) -> void
+
+      include _TypeBase
+
+      attr_reader location: loc?
+
+      def map_type: () { (t) -> t } -> Record
+                  | () -> Enumerator[t, Record]
+    end
+
+    class Optional
+      attr_reader type: t
+
+      type loc = Location[bot, bot]
+
+      def initialize: (type: t, location: loc?) -> void
+
+      include _TypeBase
+
+      attr_reader location: loc?
+
+      def map_type: () { (t) -> t } -> Optional
+                  | () -> Enumerator[t, Optional]
+    end
+
+    class Union
+      attr_reader types: Array[t]
+
+      type loc = Location[bot, bot]
+
+      def initialize: (types: Array[t], location: loc?) -> void
+
+      include _TypeBase
+
+      attr_reader location: loc?
+
+      def map_type: () { (t) -> t } -> Union
+                  | () -> Enumerator[t, Union]
+    end
+
+    class Intersection
+      attr_reader types: Array[t]
+
+      type loc = Location[bot, bot]
+
+      def initialize: (types: Array[t], location: loc?) -> void
+
+      include _TypeBase
+
+      attr_reader location: loc?
+
+      def map_type: () { (t) -> t } -> Intersection
+                  | () -> Enumerator[t, Intersection]
+    end
+
+    class Function
+      class Param
+        type loc = Location[bot, :name]
+
+        attr_reader type: t
+        attr_reader name: Symbol?
+        attr_reader location: loc?
+
+        def initialize: (type: t, name: Symbol?, ?location: loc?) -> void
+
+        def map_type: { (t) -> t } -> Param
+                    | -> Enumerator[t, Param]
+      end
+
+      attr_reader required_positionals: Array[Param]
+      attr_reader optional_positionals: Array[Param]
+      attr_reader rest_positionals: Param?
+      attr_reader trailing_positionals: Array[Param]
+      attr_reader required_keywords: Hash[Symbol, Param]
+      attr_reader optional_keywords: Hash[Symbol, Param]
+      attr_reader rest_keywords: Param?
+      attr_reader return_type: t
+
+      def initialize: (required_positionals: Array[Param],
+                       optional_positionals: Array[Param],
+                       rest_positionals: Param?,
+                       trailing_positionals: Array[Param],
+                       required_keywords: Hash[Symbol, Param],
+                       optional_keywords: Hash[Symbol, Param],
+                       rest_keywords: Param?,
+                       return_type: t) -> void
+
+      def free_variables: (?Set[Symbol]) -> Set[Symbol]
+
+      def map_type: { (t) -> t } -> Function
+                  | -> Enumerator[t, Function]
+
+      def map_type_name: () { (TypeName, Location[untyped, untyped]?, t) -> TypeName } -> Function
+
+      def each_type: () { (t) -> void } -> void
+                   | -> Enumerator[t, void]
+
+      def each_param: () { (Param) -> void } -> void
+                    | -> Enumerator[Param, void]
+
+      include _ToJson
+
+      def sub: (Substitution) -> Function
+
+      def self.empty: (t) -> instance
+
+      def with_return_type: (t) -> Function
+
+      def update: (?required_positionals: Array[Param],
+                   ?optional_positionals: Array[Param],
+                   ?rest_positionals: Param?,
+                   ?trailing_positionals: Array[Param],
+                   ?required_keywords: Hash[Symbol, Param],
+                   ?optional_keywords: Hash[Symbol, Param],
+                   ?rest_keywords: Param?,
+                   ?return_type: t) -> Function
+
+      def empty?: () -> bool
+
+      def param_to_s: () -> String
+      def return_to_s: () -> String
+
+      def drop_head: () -> [Param, Function]
+      def drop_tail: () -> [Param, Function]
+
+      def has_keyword?: () -> bool
+
+      def amap: [A, B] (Array[A]) { (A) -> B } -> Array[B]
+
+      def hmapv: [X, Y, Z] (Hash[X, Y]) { (Y) -> Z } -> Hash[X, Z]
+
+      def has_self_type?: () -> bool
+
+      def has_classish_type?: () -> bool
+
+      def with_nonreturn_void?: () -> bool
+
+      def ==: (untyped) -> bool
+
+      alias eql? ==
+
+      def hash: () -> Integer
+    end
+
+    # Function type without type checking arguments
+    #
+    class UntypedFunction
+      attr_reader return_type: t
+
+      def initialize: (return_type: t) -> void
+
+      def free_variables: (?Set[Symbol]) -> Set[Symbol]
+
+      def map_type: { (t) -> t } -> UntypedFunction
+                  | -> Enumerator[t, UntypedFunction]
+
+      def map_type_name: () { (TypeName, Location[untyped, untyped]?, t) -> TypeName } -> UntypedFunction
+
+      def each_type: () { (t) -> void } -> void
+                   | -> Enumerator[t, void]
+
+      def each_param: () { (Function::Param) -> void } -> void
+                    | -> Enumerator[Function::Param, void]
+
+      include _ToJson
+
+      def sub: (Substitution) -> UntypedFunction
+
+      def with_return_type: (t) -> UntypedFunction
+
+      def update: (?return_type: t) -> UntypedFunction
+
+      def empty?: () -> bool
+
+      def has_self_type?: () -> bool
+
+      def has_classish_type?: () -> bool
+
+      def with_nonreturn_void?: () -> bool
+
+      # Returns `?`
+      def param_to_s: () -> String
+
+      # Returns `return_type.to_s(1)`
+      def return_to_s: () -> String
+
+      def ==: (untyped) -> bool
+
+      alias eql? ==
+
+      def hash: () -> Integer
+    end
+
+    type function = Types::Function | Types::UntypedFunction
+
+    class Block
+      attr_reader type: function
+      attr_reader required: bool
+
+      attr_reader self_type: t?
+
+      type loc = Location[bot, bot]
+      attr_reader location: loc?
+
+      def initialize: (?location: loc?, type: function, ?self_type: t?, required: boolish) -> void
+
+      def ==: (untyped other) -> bool
+
+      include _ToJson
+
+      def sub: (Substitution) -> Block
+
+      def map_type: () { (t) -> t } -> Block
+    end
+
+    module SelfTypeBindingHelper
+      def self?.self_type_binding_to_s: (t?) -> String
+    end
+
+    class Proc
+      attr_reader type: function
+      attr_reader block: Block?
+
+      attr_reader self_type: t?
+
+      type loc = Location[bot, bot]
+
+      def initialize: (location: loc?, type: function, ?self_type: t?, block: Block?) -> void
+
+      include _TypeBase
+
+      attr_reader location: loc?
+
+      def map_type: () { (t) -> t } -> Proc
+                  | () -> Enumerator[t, Proc]
+    end
+
+    class Literal
+      type literal = String | Integer | Symbol | TrueClass | FalseClass
+      type loc = Location[bot, bot]
+
+      attr_reader literal: literal
+
+      def initialize: (literal: literal, location: loc?) -> void
+
+      include _TypeBase
+      include NoFreeVariables
+      include NoSubst
+      include EmptyEachType
+      include NoTypeName
+
+      attr_reader location: loc?
+
+      TABLE: Hash[String, String]
+
+      # Unescape string type body
+      def self.unescape_string: (String, bool is_double_quote) -> String
+    end
+  end
+end