rbs 0.10.0 → 0.13.0

data/sig/method_types.rbs

@@ -0,0 +1,40 @@
+module RBS
+  class MethodType
+    class Block
+      attr_reader type: Types::Function
+      attr_reader required: bool
+
+      def initialize: (type: Types::Function, required: bool) -> void
+
+      def ==: (untyped other) -> bool
+
+      def to_json: (*untyped) -> String
+
+      def sub: (Substitution) -> Block
+    end
+
+    attr_reader type_params: Array[Symbol]
+    attr_reader type: Types::Function
+    attr_reader block: Block?
+    attr_reader location: Location?
+
+    def initialize: (type_params: Array[Symbol], type: Types::Function, block: Block?, location: Location?) -> void
+
+    def ==: (untyped other) -> bool
+
+    def to_json: (*untyped) -> String
+
+    def sub: (Substitution) -> MethodType
+
+    def update: (?type_params: Array[Symbol], ?type: Types::Function, ?block: Block?, ?location: Location?) -> MethodType
+
+    def free_variables: (?Set[Symbol] set) -> Set[Symbol]
+
+    def map_type: () { (Types::t) -> Types::t } -> MethodType
+
+    def each_type: () { (Types::t) -> void } -> void
+                 | () -> Enumerator[Types::t, void]
+
+    def to_s: () -> String
+  end
+end

data/sig/namespace.rbs

@@ -0,0 +1,124 @@
+module RBS
+  # Namespace instance represents a _prefix of module names_.
+  # 
+  #    vvvvvvvvvvvvvv  TypeName
+  #    RBS::Namespace
+  #    ^^^^^           Namespace
+  #
+  #    vvvvvvvvvv    TypeName
+  #    RBS::Types
+  #    ^^^^^         Namespace
+  #
+  #    vvvvvvvvvvvvvvvvv    TypeName
+  #    RBS::Types::Union
+  #    ^^^^^^^^^^^^         Namespace
+  #
+  # Note that `Namespace` is a RBS specific concept and there is no corresponding concept in Ruby.
+  #
+  # There are _absolute_ and _relative_ namespaces.
+  #
+  #    Namespace(::RBS::)         # Absolute namespace
+  #    Namespace(  RBS::)         # Relative namespace
+  #
+  # It also defines two special namespaces.
+  #
+  #    ::              # _Root_ namespace
+  #                    # _Empty_ namespace
+  #
+  class Namespace
+    attr_reader path: Array[Symbol]
+
+    def initialize: (path: Array[Symbol], absolute: bool) -> void
+
+    # Returns new _empty_ namespace.
+    def self.empty: () -> Namespace
+
+    # Returns new _root_ namespace.
+    def self.root: () -> Namespace
+
+    # Concat two namespaces.
+    #
+    #   Namespace("Foo::") + Namespace("Bar::")   # => Foo::Bar::
+    #   Namespace("::Foo::") + Namespace("Bar::") # => ::Foo::Bar::
+    #
+    # If `other` is an absolute namespace, it returns `other`.
+    #
+    #   Namespace("Foo::") + Namespace("::Bar::")  # =>  ::Bar::
+    # 
+    def +: (Namespace other) -> Namespace
+
+    # Add one path component to self.
+    #
+    #   Namespace("Foo::").append(:Bar) # => Namespace("Foo::Bar::")
+    def append: (Symbol component) -> Namespace
+
+    # Returns parent namespace.
+    # Raises error there is no parent namespace.
+    #
+    #    Namespace("::A").parent    # => Namespace("::")
+    #    Namespace("::").parent     # raises error
+    #    Namespace("A::B").parent   # => Namespace("A")
+    def parent: () -> Namespace
+
+    # Returns true if self is absolute namespace.
+    def absolute?: () -> bool
+    
+    # Returns true if self is relative namespace.
+    def relative?: () -> bool
+
+    # Returns absolute namespace.
+    #
+    #    Namespace("A").absolute!      # => Namespace("::A")
+    #    Namespace("::A").absolute!    # => Namespace("::A")
+    #
+    def absolute!: () -> Namespace
+
+    # Returns _relative_ namespace.
+    #
+    def relative!: () -> Namespace
+
+    def empty?: () -> bool
+
+    # Equality is defined by its structure.
+    #
+    def ==: (untyped other) -> bool
+
+    alias eql? ==
+
+    # Hash is defined based on its structure.
+    #
+    def hash: () -> Integer
+
+    # Returns a pair of parent namespace and a symbol of last component.
+    #
+    #    Namespace("::A::B::C").split    # => [Namespace("::A::B::"), :C]
+    #
+    def split: () -> [Namespace, Symbol]?
+
+    def to_s: () -> String
+
+    # Construct a type name which points to the same name type.
+    #
+    def to_type_name: () -> TypeName
+
+    def self.parse: (String string) -> Namespace
+
+    # Iterate over Namespace for each element in ascending order.
+    #
+    # ```
+    # Namespace.parse("::A::B::C").ascend {|ns| p ns }
+    #   => ::A::B::C
+    #   => ::A::B
+    #   => ::A
+    #   => ::(root)
+    # ```
+    def ascend: () { (Namespace) -> void } -> void
+              | () -> Enumerator[Namespace, void]
+  end
+end
+
+module Kernel
+  # Parses given string and returns Namespace.
+  #
+  def Namespace: (String) -> RBS::Namespace
+end

data/sig/polyfill.rbs

@@ -0,0 +1,3 @@
+module Kernel
+  def to_json: (*untyped) -> String
+end

data/sig/rbs.rbs

@@ -0,0 +1,3 @@
+module RBS
+  def self.logger: () -> Logger
+end

data/sig/substitution.rbs

@@ -0,0 +1,39 @@
+module RBS
+  # Substitution from type variables to types.
+  # 
+  # The substitution construction is in _destructive_ manner.
+  #
+  #    sub = Substitution.new
+  #    sub.add(from: :A, to: type1)
+  #    sub.add(from: :B, to: type2)
+  #    sub.instance_type = type3
+  #
+  class Substitution
+    # A hash containing mapping from type variable name to type.
+    attr_reader mapping: Hash[Symbol, Types::t]
+
+    # The result of applying this substitution to `instance` type.
+    # `nil` maps to `instance` type itself.
+    attr_accessor instance_type: Types::t?
+
+    def initialize: () -> void
+
+    # Add mapping to this substitution.
+    # Overwrites the previous mapping if same `from` is given.
+    def add: (from: Symbol, to: Types::t) -> void
+
+    # Utility method to construct a substitution.
+    # Raises an error when `variables.size != types.size`.
+    # `instance_type` defaults to `nil`.
+    # 
+    # Yields types in `types` and the block value is used if block is given.
+    #
+    def self.build: (Array[Symbol] variables, Array[Types::t] types, ?instance_type: Types::t?) ?{ (Types::t) -> Types::t } -> instance
+
+    # Applies the substitution to given type.
+    def apply: (Types::t) -> Types::t
+
+    # Returns a substitution without variables given in `vars`.
+    def without: (*Symbol vars) -> Substitution
+  end
+end

data/sig/type_name_resolver.rbs

@@ -0,0 +1,24 @@
+module RBS
+  class TypeNameResolver
+    class Query
+      attr_reader type_name: TypeName
+      attr_reader context: Array[Namespace]
+
+      def initialize: (type_name: TypeName, context: Array[Namespace]) -> void
+    end
+
+    attr_reader all_names: Set[TypeName]
+
+    attr_reader cache: Hash[Query, TypeName?]
+
+    def self.from_env: (Environment) -> TypeNameResolver
+
+    def add_names: (Array[TypeName]) -> self
+
+    def resolve: (TypeName, context: Array[Namespace]) -> TypeName?
+
+    def has_name?: (TypeName) -> TypeName?
+
+    def try_cache: (Query) { () -> TypeName? } -> TypeName?
+  end
+end

data/sig/typename.rbs

@@ -0,0 +1,70 @@
+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
+
+    def ==: (untyped other) -> bool
+
+    def hash: () -> Integer
+
+    def to_s: () -> ::String
+
+    def to_json: (*untyped a) -> untyped
+
+    # 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.
+    #
+    #    TypeName("Hello").with_prefix(Namespace("World"))           # => World::Hello
+    #    TypeName("Foo::Bar").with_prefix(Namespace("::Hello"))      # => ::Hello::Foo::Bar
+    #    TypeName("::A::B").with_prefix(Namespace("C"))              # => ::A::B
+    #
+    def with_prefix: (Namespace namespace) -> TypeName
+  end
+end
+
+module Kernel
+  # Returns type name with given string representation.
+  def TypeName: (String name) -> RBS::TypeName
+end

data/sig/types.rbs

@@ -0,0 +1,361 @@
+module RBS
+  module Types
+    # _TypeBase interface represents the operations common to all of the types.
+    #
+    interface _TypeBase
+      # Location for types in the RBS source code.
+      # `nil` means there is no RBS source code for the type.
+      #
+      def location: () -> Location?
+
+      # 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?, t) -> TypeName } -> t
+
+      # Yields all direct sub types included in the type.
+      # It doesn't yield the type itself.
+      #
+      #   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.
+      #
+      def to_json: (*untyped) -> String
+
+      # Returns a String representation.
+      # `level` is used internally.
+      #
+      #   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
+    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]
+    end
+
+    module NoTypeName
+      def map_type_name: () { (TypeName, Location?, t) -> TypeName } -> self
+    end
+
+    module Bases
+      class Base
+        include _TypeBase
+
+        def initialize: (location: Location?) -> 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
+      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
+      attr_reader name: Symbol
+      attr_reader location: Location?
+
+      @@count: Integer
+
+      include _TypeBase
+
+      include NoTypeName
+      include EmptyEachType
+
+      def initialize: (name: Symbol, location: Location?) -> void
+
+      def ==: (untyped other) -> bool
+
+      alias eql? ==
+
+      def hash: () -> Integer
+
+      def self.build: (Symbol) -> Variable
+                    | (Array[Symbol]) -> Array[Variable]
+
+      def self.fresh: (?Symbol) -> Variable
+    end
+
+    class ClassSingleton
+      attr_reader name: TypeName
+      attr_reader location: Location?
+
+      include _TypeBase
+
+      def initialize: (name: TypeName, location: Location?) -> void
+
+      def ==: (untyped other) -> bool
+
+      alias eql? ==
+
+      def hash: () -> Integer
+
+      include NoFreeVariables
+      include NoSubst
+      include EmptyEachType      
+    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]
+    end
+
+    class Interface
+      include Application
+
+      attr_reader location: Location?
+
+      def initialize: (name: TypeName, args: Array[t], location: Location?) -> void
+
+      include _TypeBase
+    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
+
+      attr_reader location: Location?
+
+      def initialize: (name: TypeName, args: Array[t], location: Location?) -> void
+
+      include _TypeBase
+    end
+
+    class Alias
+      attr_reader location: Location?
+      attr_reader name: TypeName
+
+      def initialize: (name: TypeName, location: Location?) -> void
+
+      include _TypeBase
+      include NoFreeVariables
+      include NoSubst
+      include EmptyEachType
+    end
+
+    class Tuple
+      attr_reader types: Array[t]
+      attr_reader location: Location?
+
+      def initialize: (types: Array[t], location: Location?) -> void
+
+      include _TypeBase
+    end
+
+    class Record
+      attr_reader fields: Hash[Symbol, t]
+      attr_reader location: Location?
+
+      def initialize: (fields: Hash[Symbol, t], location: Location?) -> void
+
+      include _TypeBase
+    end
+
+    class Optional
+      attr_reader type: t
+      attr_reader location: Location?
+
+      def initialize: (type: t, location: Location?) -> void
+
+      include _TypeBase
+    end
+
+    class Union
+      attr_reader types: Array[t]
+      attr_reader location: Location?
+
+      def initialize: (types: Array[t], location: Location?) -> void
+
+      include _TypeBase
+
+      def map_type: () { (t) -> t } -> Union
+                  | () -> Enumerator[t, Union]
+    end
+
+    class Intersection
+      attr_reader types: Array[t]
+      attr_reader location: Location?
+
+      def initialize: (types: Array[t], location: Location?) -> void
+
+      include _TypeBase
+
+      def map_type: () { (t) -> t } -> Intersection
+                  | () -> Enumerator[t, Intersection]
+    end
+
+    class Function
+      class Param
+        attr_reader type: t
+        attr_reader name: Symbol?
+
+        def initialize: (type: t, name: Symbol?) -> 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?, t) -> TypeName } -> Function
+
+      def each_type: () { (t) -> void } -> void
+                   | -> Enumerator[t, void]
+
+      def each_param: () { (Param) -> void } -> void
+                    | -> Enumerator[Param, void]
+
+      def to_json: (*untyped) -> String
+
+      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
+    end
+
+    class Proc
+      attr_reader type: Function
+      attr_reader location: Location?
+
+      def initialize: (location: Location?, type: Function) -> void
+
+      include _TypeBase
+    end
+
+    class Literal
+      type literal = String | Integer | Symbol | TrueClass | FalseClass
+
+      attr_reader literal: literal
+      attr_reader location: Location?
+
+      def initialize: (literal: literal, location: Location?) -> void
+
+      include _TypeBase
+      include NoFreeVariables
+      include NoSubst
+      include EmptyEachType
+      include NoTypeName
+    end
+  end
+end