rbs 1.7.0 → 2.0.0.pre1

data/sig/declarations.rbs

@@ -6,56 +6,6 @@ module RBS
       class Base
       end
 
-      type variance = :invariant | :covariant | :contravariant
-
-      class ModuleTypeParams
-        class TypeParam
-          # Key
-          # ^^^ name
-          #
-          # unchecked out Elem
-          # ^^^^^^^^^          unchecked
-          #           ^^^      variance
-          #               ^^^^ name
-          type loc = Location[:name, :variance | :unchecked]
-
-          attr_reader name: Symbol
-          attr_reader variance: variance
-          attr_reader skip_validation: bool
-          attr_reader location: loc?
-
-          def initialize: (name: Symbol, variance: variance, skip_validation: boolish, location: loc?) -> 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
@@ -118,14 +68,14 @@ module RBS
         include MixinHelper
 
         attr_reader name: TypeName
-        attr_reader type_params: ModuleTypeParams
+        attr_reader type_params: Array[TypeParam]
         attr_reader members: Array[member]
         attr_reader super_class: Super?
         attr_reader annotations: Array[Annotation]
         attr_reader location: loc?
         attr_reader comment: Comment?
 
-        def initialize: (name: TypeName, type_params: ModuleTypeParams, members: Array[member], super_class: Super?, annotations: Array[Annotation], location: loc?, comment: Comment?) -> void
+        def initialize: (name: TypeName, type_params: Array[TypeParam], members: Array[member], super_class: Super?, annotations: Array[Annotation], location: loc?, comment: Comment?) -> void
 
         include _HashEqual
         include _ToJson
@@ -172,14 +122,14 @@ module RBS
         include MixinHelper
 
         attr_reader name: TypeName
-        attr_reader type_params: ModuleTypeParams
+        attr_reader type_params: Array[TypeParam]
         attr_reader members: Array[member]
         attr_reader location: loc?
         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: loc?, annotations: Array[Annotation], self_types: Array[Self], comment: Comment?) -> void
+        def initialize: (name: TypeName, type_params: Array[TypeParam], members: Array[member], location: loc?, annotations: Array[Annotation], self_types: Array[Self], comment: Comment?) -> void
 
         include _HashEqual
         include _ToJson
@@ -202,13 +152,13 @@ module RBS
         type loc = Location[:name | :keyword | :end, :type_params]
 
         attr_reader name: TypeName
-        attr_reader type_params: ModuleTypeParams
+        attr_reader type_params: Array[TypeParam]
         attr_reader members: Array[member]
         attr_reader annotations: Array[Annotation]
         attr_reader location: loc?
         attr_reader comment: Comment?
 
-        def initialize: (name: TypeName, type_params: ModuleTypeParams, members: Array[member], annotations: Array[Annotation], location: loc?, comment: Comment?) -> void
+        def initialize: (name: TypeName, type_params: Array[TypeParam], members: Array[member], annotations: Array[Annotation], location: loc?, comment: Comment?) -> void
 
         include MixinHelper
 
@@ -217,19 +167,22 @@ module RBS
       end
 
       class Alias < Base
-        # type loc = Location
-        # ^^^^                keyword
-        #      ^^^            name
-        #          ^          eq
-        type loc = Location[:keyword | :name | :eq, bot]
+        # type loc[T] = Location[T, bot]
+        # ^^^^                            keyword
+        #      ^^^                        name
+        #         ^^^                     type_params
+        #             ^                      eq
+        #
+        type loc = Location[:keyword | :name | :eq, :type_params]
 
         attr_reader name: TypeName
+        attr_reader type_params: Array[TypeParam]
         attr_reader type: Types::t
         attr_reader annotations: Array[Annotation]
         attr_reader location: loc?
         attr_reader comment: Comment?
 
-        def initialize: (name: TypeName, type: Types::t, annotations: Array[Annotation], location: loc?, comment: Comment?) -> void
+        def initialize: (name: TypeName, type_params: Array[TypeParam], type: Types::t, annotations: Array[Annotation], location: loc?, comment: Comment?) -> void
 
         include _HashEqual
         include _ToJson

data/sig/definition.rbs

@@ -54,10 +54,20 @@ module RBS
 
       def private?: () -> bool
 
+      # Substitutes type variables to some types.
+      # Takes care of type parameter bounds.
+      #
       def sub: (Substitution) -> Method
 
+      # Applies the mapping from `Types::t` to `Types::t`.
+      #
+      # Note this method doesn't handle upper bound in type params.
+      # You may want to use `#map_type_bound` explicitly, or `#sub` for simple substitution.
+      #
       def map_type: () { (Types::t) -> Types::t } -> Method
 
+      def map_type_bound: () { (AST::TypeParam::bound) -> AST::TypeParam::bound } -> Method
+
       def map_method_type: () { (MethodType) -> MethodType } -> Method
     end
 
@@ -127,7 +137,7 @@ module RBS
 
     def type_params: () -> Array[Symbol]
 
-    def type_params_decl: () -> AST::Declarations::ModuleTypeParams
+    def type_params_decl: () -> Array[AST::TypeParam]
 
     def sub: (Substitution) -> Definition
 

data/sig/definition_builder.rbs

@@ -33,7 +33,7 @@ module RBS
     def try_cache: (TypeName, cache: Hash[TypeName, Definition | false | nil]) { () -> Definition } -> Definition
                  | [A] (TypeName, cache: Hash[A, Definition | false | nil], key: A) { () -> Definition } -> Definition
 
-    def validate_params_with: (AST::Declarations::ModuleTypeParams, result: VarianceCalculator::Result) { (AST::Declarations::ModuleTypeParams::TypeParam) -> void } -> void
+    def validate_params_with: (Array[AST::TypeParam], result: VarianceCalculator::Result) { (AST::TypeParam) -> void } -> void
 
     def validate_type_params: (Definition, ancestors: AncestorBuilder::OneAncestors, methods: MethodBuilder::Methods) -> void
 
@@ -43,8 +43,44 @@ module RBS
 
     def define_methods: (Definition, interface_methods: Hash[Symbol, Definition::Method], methods: MethodBuilder::Methods, super_interface_method: bool) -> void
 
+    # Validates presence of type names recursively.
+    # Assumes the type names are already resolved.
+    #
+    def validate_type_presence: (Types::t) -> void
+
+    def validate_type_name: (TypeName, Location[untyped, untyped]?) -> void
+
+    # Expand a type alias of given name without type arguments.
+    # Raises an error if the type alias requires arguments.
+    #
+    # Assume `type foo[T] = [T, T]`:
+    #
+    # ```
+    # expand_alias("::foo")   # => error
+    # ```
+    #
     def expand_alias: (TypeName) -> Types::t
 
+    # Expand a type alias of given name with arguments of `untyped`.
+    #
+    # Assume `type foo[T] = [T, T]`:
+    #
+    # ```
+    # expand_alias1("::foo")   # => [untyped, untyped]
+    # ```
+    #
+    def expand_alias1: (TypeName) -> Types::t
+
+    # Expand a type alias of given name with `args`.
+    #
+    # Assume `type foo[T] = [T, T]`:
+    #
+    # ```
+    # expand_alias2("::foo", ["::Integer"])   # => [::Integer, ::Integer]
+    # ```
+    #
+    def expand_alias2: (TypeName, Array[Types::t] args) -> Types::t
+
     def update: (env: Environment, ancestor_builder: AncestorBuilder, except: _Each[TypeName]) -> DefinitionBuilder
   end
 end

data/sig/environment.rbs

@@ -31,7 +31,9 @@ module RBS
 
       def validate_type_params: () -> void
 
-      def type_params: () -> AST::Declarations::ModuleTypeParams
+      def compatible_params?: (Array[AST::TypeParam], Array[AST::TypeParam]) -> boolish
+
+      def type_params: () -> Array[AST::TypeParam]
 
       def primary: () -> D[module_decl]
     end
@@ -96,6 +98,10 @@ module RBS
 
     def resolve_member: (TypeNameResolver, AST::Members::t, context: Array[Namespace]) -> AST::Members::t
 
+    def resolve_method_type: (TypeNameResolver, RBS::MethodType, context: Array[Namespace]) -> RBS::MethodType
+
+    def resolve_type_params: (TypeNameResolver resolver, Array[AST::TypeParam], context: Array[Namespace]) ->  Array[AST::TypeParam]
+
     def absolute_type: (TypeNameResolver, Types::t, context: Array[Namespace]) -> Types::t
 
     def absolute_type_name: (TypeNameResolver, TypeName, context: Array[Namespace]) -> TypeName

data/sig/environment_walker.rbs

@@ -1,4 +1,28 @@
 module RBS
+  # EnvironmentWalker provides topological sort of class/module definitions.
+  #
+  # If a method, attribute, or ancestor in a class definition have a reference to another class, it is dependency.
+  #
+  # ```rb
+  # walker = EnvironmentWalker.new(env: env)
+  #
+  # walker.each_strongly_connected_component do |scc|
+  #   # Yields an array of strongly connected components.
+  # end
+  # ```
+  #
+  # The `#only_ancestors!` method limits the dependency only to ancestors.
+  # Only super classes and included modules are dependencies with the option.
+  # This is useful to calculate the dependencies of class hierarchy.
+  #
+  # ```rb
+  # walker = EnvironmentWalker.new(env: env).only_ancestors!
+  #
+  # walker.each_strongly_connected_component do |scc|
+  #   # Yields an array of strongly connected components.
+  # end
+  # ```
+  #
   class EnvironmentWalker
     class InstanceNode
       attr_reader type_name: TypeName
@@ -32,6 +56,8 @@ module RBS
 
     def tsort_each_child: (node) { (node) -> void } -> void
 
+    private
+
     def each_type_name: (Types::t) { (TypeName) -> void } -> void
 
     def each_type_node: (Types::t) { (node) -> void } -> void

data/sig/errors.rbs

@@ -179,10 +179,10 @@ module RBS
 
   class InvalidVarianceAnnotationError < DefinitionError
     attr_reader type_name: TypeName
-    attr_reader param: AST::Declarations::ModuleTypeParams::TypeParam
+    attr_reader param: AST::TypeParam
     attr_reader location: Location[untyped, untyped]?
 
-    def initialize: (type_name: TypeName, param: AST::Declarations::ModuleTypeParams::TypeParam, location: Location[untyped, untyped]?) -> void
+    def initialize: (type_name: TypeName, param: AST::TypeParam, location: Location[untyped, untyped]?) -> void
   end
 
   class RecursiveAliasDefinitionError < DefinitionError
@@ -212,7 +212,7 @@ module RBS
     def mixin_name: () -> String
   end
 
-  class RecursiveTypeAliasError < LoadingError
+  class RecursiveTypeAliasError < BaseError
     attr_reader alias_names: Array[TypeName]
     attr_reader location: Location[untyped, untyped]?
 
@@ -220,4 +220,29 @@ module RBS
 
     def name: () -> String
   end
+
+  class NonregularTypeAliasError < BaseError
+    # Diagnostic reported from `TypeAliasRegularity`.
+    attr_reader diagnostic: TypeAliasRegularity::Diagnostic
+
+    # Location of the definition.
+    attr_reader location: Location[untyped, untyped]?
+
+    def initialize: (diagnostic: TypeAliasRegularity::Diagnostic, location: Location[untyped, untyped]?) -> void
+  end
+
+  class CyclicTypeParameterBound < BaseError
+    attr_reader location: Location[untyped, untyped]?
+
+    # Array of parameters which contains cyclic dependencies.
+    attr_reader params: Array[AST::TypeParam]
+
+    # Type name
+    attr_reader type_name: TypeName
+
+    # Method name
+    attr_reader method_name: Symbol?
+
+    def initialize: (type_name: TypeName, method_name: Symbol?, params: Array[AST::TypeParam], location: Location[untyped, untyped]?) -> void
+  end
 end

data/sig/location.rbs

@@ -8,7 +8,7 @@ module RBS
   #
   # ```
   #
-  class Location[RequiredChildKeys, OptionalChildKeys]
+  class Location[in RequiredChildKeys, in OptionalChildKeys]
     # The buffer this location points on.
     attr_reader buffer (): Buffer
 
@@ -79,6 +79,8 @@ module RBS
           | (OptionalChildKeys) -> Location[bot, bot]?
           | (Symbol) -> Location[bot, bot]?
 
+    alias aref []
+
     def each_optional_key: () { (Symbol) -> void } -> void
                          | () -> Enumerator[Symbol, void]
 

data/sig/locator.rbs

@@ -7,7 +7,7 @@ module RBS
                    | MethodType
                    | AST::Declarations::t
                    | AST::Members::t
-                   | AST::Declarations::ModuleTypeParams::TypeParam
+                   | AST::TypeParam
                    | AST::Declarations::Class::Super
                    | AST::Declarations::Module::Self
 

data/sig/method_types.rbs

@@ -1,27 +1,48 @@
 module RBS
   class MethodType
-    attr_reader type_params: Array[Symbol]
+    # () -> void
+    # ^^^^^^^^^^     type
+    #
+    # [A] () { () -> A } -> A
+    # ^^^                      type_params
+    #     ^^^^^^^^^^^^^^^^^^^  type
+    #
+    type loc = Location[:type, :type_params]
+
+    attr_reader type_params: Array[AST::TypeParam]
     attr_reader type: Types::Function
     attr_reader block: Types::Block?
-    attr_reader location: Location[untyped, untyped]?
+    attr_reader location: loc?
 
-    def initialize: (type_params: Array[Symbol], type: Types::Function, block: Types::Block?, location: Location[untyped, untyped]?) -> void
+    def initialize: (type_params: Array[AST::TypeParam], type: Types::Function, block: Types::Block?, location: loc?) -> void
 
     def ==: (untyped other) -> bool
 
     include _ToJson
 
+    # Substitute type variables to some types.
+    # Takes care of type parameter bounds.
+    #
     def sub: (Substitution) -> MethodType
 
-    def update: (?type_params: Array[Symbol], ?type: Types::Function, ?block: Types::Block?, ?location: Location[untyped, untyped]?) -> MethodType
+    def update: (?type_params: Array[AST::TypeParam], ?type: Types::Function, ?block: Types::Block?, ?location: loc?) -> MethodType
 
     def free_variables: (?Set[Symbol] set) -> Set[Symbol]
 
+    # Apply the mapping included in the MethodType.
+    #
+    # Note that type bound in generics parameter is not handled by this method.
+    # You may want to use `#map_type_bound` explicitly, or `#sub` for simple substitution.
+    #
     def map_type: () { (Types::t) -> Types::t } -> MethodType
 
+    def map_type_bound: () { (AST::TypeParam::bound) -> AST::TypeParam::bound } -> MethodType
+
     def each_type: () { (Types::t) -> void } -> void
                  | () -> Enumerator[Types::t, void]
 
     def to_s: () -> String
+
+    def type_param_names: () -> Array[Symbol]
   end
 end

data/sig/type_alias_regularity.rbs

@@ -0,0 +1,92 @@
+module RBS
+  # `TypeAliasRegularity` validates if a type alias is regular or not.
+  #
+  # Generic and recursive type alias cannot be polymorphic in their definitions.
+  #
+  # ```rbs
+  # type foo[T] = Integer
+  #             | foo[T]?     # Allowed. The type argument of `foo` doesn't change.
+  #
+  # type bar[T] = Integer
+  #             | foo[T]
+  #             | foo[Array[T]]  # Allowed. There are two type arguments `T` and `Array[T]` of `foo`, but it's not definition of `foo`.
+  #
+  # type baz[T] = Integer
+  #             | baz[Array[T]]  # Error. Recursive definition of `baz` has different type argument from the definition.
+  # ```
+  #
+  # The `#nonregular?` method can be used to test if given type name is regular or not.
+  #
+  # ```rb
+  # validator = RBS::TypeAliasRegularity.validate(env: env)
+  #
+  # validator.nonregular?(TypeName("::foo"))    # => nil
+  # validator.nonregular?(TypeName("::bar"))    # => nil
+  # validator.nonregular?(TypeName("::baz"))    # => TypeAliasRegularity::Diagnostic
+  # ```
+  #
+  # A special case is when the type argument is `untyped`.
+  #
+  # ```rbs
+  # type foo[T] = Integer | foo[untyped]    # This is allowed.
+  # ```
+  #
+  class TypeAliasRegularity
+    attr_reader env: Environment
+
+    attr_reader builder: DefinitionBuilder
+
+    attr_reader diagnostics: Hash[TypeName, Diagnostic]
+
+    # `Diagnostic` represents an non-regular type alias declaration error.
+    # It consists of the name of the alias type and a type on which the nonregularity is detected.
+    #
+    # ```rbs
+    # type t[T] = Integer | t[T?]
+    # ```
+    #
+    # The type `t` is nonregular because it contains `t[T?]` on it's right hand side.
+    #
+    # ```
+    # diagnostic = validator.nonregular?(TypeName("::t"))
+    # diagnostic.type_name         # => TypeName("::t")
+    # diagnostic.nonregular_type   # => t[T?]
+    # ```
+    #
+    class Diagnostic
+      attr_reader type_name: TypeName
+
+      attr_reader nonregular_type: Types::Alias
+
+      def initialize: (type_name: TypeName, nonregular_type: Types::Alias) -> void
+    end
+
+    # Returns new instance which already run `#validate`.
+    #
+    def self.validate: (env: Environment) -> TypeAliasRegularity
+
+    def initialize: (env: Environment) -> void
+
+    # Returns `Diagnostic` instance if the alias type is nonregular.
+    # Regurns `nil` if the alias type is regular.
+    #
+    def nonregular?: (TypeName) -> Diagnostic?
+
+    def validate: () -> void
+
+    private
+
+    def validate_alias_type: (Types::Alias, Set[TypeName], Hash[TypeName, Types::Alias]) -> void
+
+    # Returns alias type for given type name, if the alias is generic.
+    # Returns nil if the type alias is not generic.
+    #
+    def build_alias_type: (TypeName) -> Types::Alias?
+
+    def compatible_args?: (Array[Types::t], Array[Types::t]) -> boolish
+
+    def each_alias_type: (Types::t) { (Types::Alias) -> void } -> void
+
+    def each_mutual_alias_defs: () { (Set[TypeName]) -> void } -> void
+  end
+end

data/sig/type_param.rbs

@@ -0,0 +1,74 @@
+module RBS
+  module AST
+    class TypeParam
+      # Key
+      # ^^^ name
+      #
+      # unchecked out Elem < _ToJson
+      # ^^^^^^^^^                    unchecked
+      #           ^^^                variance
+      #               ^^^^           name
+      #                    ^^^^^^^^^ upper_bound
+      type loc = Location[:name, :variance | :unchecked | :upper_bound]
+
+      type variance = :invariant | :covariant | :contravariant
+
+      type bound = Types::ClassInstance | Types::ClassSingleton | Types::Interface
+
+      attr_reader name: Symbol
+      attr_reader variance: variance
+      attr_reader location: loc?
+
+      attr_reader upper_bound: bound?
+
+      def initialize: (name: Symbol, variance: variance, upper_bound: bound?, location: loc?) -> void
+
+      include _ToJson
+
+      def ==: (untyped) -> bool
+
+      def eql?: (untyped) -> bool
+
+      def hash: () -> Integer
+
+      @unchecked: bool
+
+      def unchecked!: (?boolish) -> self
+
+      def unchecked?: () -> bool
+
+      def map_type: () { (bound) -> bound } -> TypeParam
+
+      # Helper function to resolve _class instance types_ to _type variables_.
+      #
+      # We need this step because RBS language has an identical syntax for both unqualified class instance types and type variables.
+      # `String` may be an instance of `::String` class or type variable depending on the list of bound type variables.
+      #
+      # So, we need second pass to parse the following generics parameter declaration.
+      #
+      # ```rbs
+      # class Foo[X < _Each[Y], Y]
+      #                   # ^ We want this `Y` to be a type variable.
+      # end
+      # ```
+      #
+      def self.resolve_variables: (Array[TypeParam]) -> void
+
+      def self.subst_var: (Set[Symbol], Types::t) -> Types::t
+
+      # Rename type parameter name.
+      #
+      # The renaming cannot be done separately because a set of `TypeParam` decls may be mutual recursive.
+      #
+      # Example:
+      #
+      # * Renaming `A -> X, B -> Y`
+      # * Input `[A, B < _Pushable[A]]`
+      # * Result `[X, Y < _Pushable[X]]`
+      #
+      def self.rename: (Array[TypeParam], new_names: Array[Symbol]) -> Array[TypeParam]
+
+      def to_s: () -> String
+    end
+  end
+end

data/sig/types.rbs

@@ -55,6 +55,11 @@ module RBS
     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
@@ -199,6 +204,9 @@ module RBS
       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.
@@ -224,21 +232,30 @@ module RBS
       attr_reader location: loc?
 
       include _TypeBase
+
+      def map_type: () { (t) -> t } -> ClassInstance
+                  | () -> Enumerator[t, ClassInstance]
     end
 
     class Alias
-      attr_reader name: TypeName
+      # foo
+      # ^^^ => name
+      #
+      # foo[bar, baz]
+      # ^^^           => name
+      #    ^^^^^^^^^^ => args
+      #
+      type loc = Location[:name, :args]
 
-      type loc = Location[bot, bot]
+      attr_reader location: loc?
 
-      def initialize: (name: TypeName, location: loc?) -> void
+      def initialize: (name: TypeName, args: Array[t], location: loc?) -> void
 
       include _TypeBase
-      include NoFreeVariables
-      include NoSubst
-      include EmptyEachType
+      include Application
 
-      attr_reader location: loc?
+      def map_type: () { (t) -> t } -> Alias
+                  | () -> Enumerator[t, Alias]
     end
 
     class Tuple
@@ -251,6 +268,9 @@ module RBS
       include _TypeBase
 
       attr_reader location: loc?
+
+      def map_type: () { (t) -> t } -> Tuple
+                  | () -> Enumerator[t, Tuple]
     end
 
     class Record
@@ -263,6 +283,9 @@ module RBS
       include _TypeBase
 
       attr_reader location: loc?
+
+      def map_type: () { (t) -> t } -> Record
+                  | () -> Enumerator[t, Record]
     end
 
     class Optional
@@ -275,6 +298,9 @@ module RBS
       include _TypeBase
 
       attr_reader location: loc?
+
+      def map_type: () { (t) -> t } -> Optional
+                  | () -> Enumerator[t, Optional]
     end
 
     class Union
@@ -392,7 +418,7 @@ module RBS
 
       def sub: (Substitution) -> Block
 
-      def map_type: () { (Types::t) -> Types::t } -> Block
+      def map_type: () { (t) -> t } -> Block
     end
 
     class Proc
@@ -406,6 +432,9 @@ module RBS
       include _TypeBase
 
       attr_reader location: loc?
+
+      def map_type: () { (t) -> t } -> Proc
+                  | () -> Enumerator[t, Proc]
     end
 
     class Literal