rbs 4.1.0.pre.2-java

data/sig/declarations.rbs

@@ -0,0 +1,274 @@
+module RBS
+  module AST
+    module Declarations
+      type t = Class | Module | Interface | Constant | Global | TypeAlias | ClassAlias | ModuleAlias
+
+      class Base
+      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
+        class Super
+          # String
+          # ^^^^^^  name
+          #
+          # Array[String]
+          # ^^^^^         name
+          #      ^^^^^^^^ args
+          #
+          type loc = Location[:name, :args]
+
+          attr_reader name: TypeName
+          attr_reader args: Array[Types::t]
+          attr_reader location: loc?
+
+          def initialize: (name: TypeName, args: Array[Types::t], location: loc?) -> void
+
+          include _HashEqual
+          include _ToJson
+        end
+
+        type member = Members::t | t
+
+        # class Foo end
+        # ^^^^^         keyword
+        #       ^^^     name
+        #           ^^^ end
+        #
+        # class Foo[A] < String end
+        # ^^^^^                     keyword
+        #       ^^^                 name
+        #          ^^^              type_params
+        #              ^            lt
+        #                       ^^^ end
+        #
+        type loc = Location[:keyword | :name | :end, :type_params | :lt]
+
+        include NestedDeclarationHelper
+        include MixinHelper
+
+        attr_reader name: TypeName
+        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: Array[TypeParam], members: Array[member], super_class: Super?, annotations: Array[Annotation], location: loc?, comment: Comment?) -> void
+
+        def update: (?name: TypeName, ?type_params: Array[TypeParam], ?members: Array[member], ?super_class: Super?, ?annotations: Array[Annotation], ?location: loc?, ?comment: Comment?) -> Declarations::Class
+
+        include _HashEqual
+        include _ToJson
+      end
+
+      class Module < Base
+        class Self
+          # _Each[String]
+          # ^^^^^         name
+          #      ^^^^^^^^ args
+          #
+          type loc = Location[:name, :args]
+
+          attr_reader name: TypeName
+          attr_reader args: Array[Types::t]
+          attr_reader location: loc?
+
+          def initialize: (name: TypeName, args: Array[Types::t], location: loc?) -> void
+
+          include _HashEqual
+          include _ToJson
+
+          def to_s: () -> String
+        end
+
+        type member = Members::t | t
+
+        # module Foo end
+        # ^^^^^^         keyword
+        #        ^^^     name
+        #            ^^^ end
+        #
+        # module Foo[A] : BasicObject end
+        # ^^^^^^                          keyword
+        #        ^^^                      name
+        #           ^^^                   type_params
+        #               ^                 colon
+        #                 ^^^^^^^^^^^     self_types
+        #                             ^^^ end
+        #
+        type loc = Location[:keyword | :name | :end, :type_params | :colon | :self_types]
+
+        include NestedDeclarationHelper
+        include MixinHelper
+
+        attr_reader name: TypeName
+        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: Array[TypeParam], members: Array[member], location: loc?, annotations: Array[Annotation], self_types: Array[Self], comment: Comment?) -> void
+
+        def update: (?name: TypeName, ?type_params: Array[TypeParam], ?members: Array[member], ?location: loc?, ?annotations: Array[Annotation], ?self_types: Array[Self], ?comment: Comment?) -> Declarations::Module
+
+        include _HashEqual
+        include _ToJson
+      end
+
+      class Interface < Base
+        type member = Members::t
+
+        # interface _Foo end
+        # ^^^^^^^^^          keyword
+        #           ^^^^     name
+        #                ^^^ end
+        #
+        # interface _Bar[A, B] end
+        # ^^^^^^^^^                keyword
+        #           ^^^^           name
+        #               ^^^^^^     type_params
+        #                      ^^^ end
+        #
+        type loc = Location[:name | :keyword | :end, :type_params]
+
+        attr_reader name: TypeName
+        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: Array[TypeParam], members: Array[member], annotations: Array[Annotation], location: loc?, comment: Comment?) -> void
+
+        def update: (?name: TypeName, ?type_params: Array[TypeParam], ?members: Array[member], ?annotations: Array[Annotation], ?location: loc?, ?comment: Comment?) -> Declarations::Interface
+
+        include MixinHelper
+
+        include _HashEqual
+        include _ToJson
+      end
+
+      class TypeAlias < Base
+        # 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_params: Array[TypeParam], type: Types::t, annotations: Array[Annotation], location: loc?, comment: Comment?) -> void
+
+        include _HashEqual
+        include _ToJson
+      end
+
+      class Constant < Base
+        # VERSION: String
+        # ^^^^^^^         name
+        #        ^        colon
+        #
+        type loc = Location[:name | :colon, bot]
+
+        attr_reader name: TypeName
+        attr_reader type: Types::t
+        attr_reader location: loc?
+        attr_reader comment: Comment?
+        attr_reader annotations: Array[Annotation]
+
+        def initialize: (name: TypeName, type: Types::t, location: loc?, comment: Comment?, annotations: Array[Annotation]) -> void
+                      | %a{deprecated} (name: TypeName, type: Types::t, location: loc?, comment: Comment?) -> void
+
+        include _HashEqual
+        include _ToJson
+      end
+
+      class Global < Base
+        # $SIZE: String
+        # ^^^^^         name
+        #      ^        colon
+        #
+        type loc = Location[:name | :colon, bot]
+
+        attr_reader name: Symbol
+        attr_reader type: Types::t
+        attr_reader location: loc?
+        attr_reader comment: Comment?
+        attr_reader annotations: Array[Annotation]
+
+        def initialize: (name: Symbol, type: Types::t, location: loc?, comment: Comment?, annotations: Array[Annotation]) -> void
+                      | %a{deprecated} (name: Symbol, type: Types::t, location: loc?, comment: Comment?) -> void
+
+        include _HashEqual
+        include _ToJson
+      end
+
+      class AliasDecl < Base
+        # module Foo = Bar
+        # ^^^^^^             keyword
+        #        ^^^         new_name
+        #            ^       eq
+        #              ^^^   old_name
+        #
+        # class Foo = Bar
+        # ^^^^^              keyword
+        #
+        type loc = Location[:keyword | :new_name | :eq | :old_name, bot]
+
+        attr_reader new_name: TypeName
+
+        attr_reader old_name: TypeName
+
+        attr_reader location: loc?
+
+        attr_reader comment: Comment?
+
+        attr_reader annotations: Array[Annotation]
+
+        def initialize: (new_name: TypeName, old_name: TypeName, location: loc?, comment: Comment?, annotations: Array[Annotation]) -> void
+                      | %a{deprecated} (new_name: TypeName, old_name: TypeName, location: loc?, comment: Comment?) -> void
+
+        include _HashEqual
+      end
+
+      class ClassAlias < AliasDecl
+        include _ToJson
+      end
+
+      class ModuleAlias < AliasDecl
+        include _ToJson
+      end
+    end
+  end
+end

data/sig/definition.rbs

@@ -0,0 +1,232 @@
+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
+      type source = AST::Members::AttrAccessor
+                  | AST::Members::AttrReader
+                  | AST::Members::AttrWriter
+                  | AST::Members::InstanceVariable
+                  | AST::Members::ClassVariable
+                  | AST::Members::ClassInstanceVariable
+                  | AST::Ruby::Members::AttrReaderMember
+                  | AST::Ruby::Members::AttrWriterMember
+                  | AST::Ruby::Members::AttrAccessorMember
+                  | AST::Ruby::Members::InstanceVariableMember
+      attr_reader source: source
+
+      def initialize: (parent_variable: Variable?, type: Types::t, declared_in: TypeName, source: source) -> void
+
+      def sub: (Substitution) -> Variable
+    end
+
+    class Method
+      type method_member = AST::Members::MethodDefinition | AST::Members::AttrReader | AST::Members::AttrAccessor | AST::Members::AttrWriter
+                         | AST::Ruby::Members::DefMember | AST::Ruby::Members::AttrReaderMember | AST::Ruby::Members::AttrWriterMember | AST::Ruby::Members::AttrAccessorMember
+
+      class TypeDef
+        attr_reader type: MethodType
+        attr_reader member: method_member
+        attr_reader defined_in: TypeName
+        attr_reader implemented_in: TypeName?
+
+        # Annotations given to the method definition syntax
+        #
+        # If the method have multiple syntaxes, union of the annotations to the member will be included, without dedup.
+        #
+        # The value should be updated during setup.
+        #
+        attr_reader member_annotations: Array[AST::Annotation]
+
+        # Annotations given to the overload associated to the method type
+        #
+        # The value should be updated during setup.
+        #
+        attr_reader overload_annotations: Array[AST::Annotation]
+
+        # Always returns an empty array
+        %a{deprecated} attr_reader annotations: Array[AST::Annotation]
+
+        # `overload_annotations` is ignored.
+        def initialize: (
+            type: MethodType,
+            member: method_member,
+            defined_in: TypeName,
+            implemented_in: TypeName?
+          ) -> void
+        | %a{deprecated} (
+            type: MethodType,
+            member: method_member,
+            defined_in: TypeName,
+            implemented_in: TypeName?,
+            overload_annotations: nil
+          ) -> void
+
+        def comment: () -> AST::Comment?
+
+        def update: (?type: MethodType, ?member: method_member, ?defined_in: TypeName, ?implemented_in: TypeName?) -> TypeDef
+
+        def overload?: () -> bool
+
+        # Yields member and overload annotations, without dedup
+        #
+        # Member annotation yields first.
+        #
+        def each_annotation: () { (AST::Annotation) -> void } -> void
+                           | () -> Enumerator[AST::Annotation]
+      end
+
+      attr_reader super_method: Method?
+      attr_reader defs: Array[TypeDef]
+      attr_reader accessibility: accessibility
+
+      attr_reader defined_in: TypeName?
+      attr_reader implemented_in: TypeName?
+      attr_reader method_types: Array[MethodType]
+      attr_reader comments: Array[AST::Comment]
+
+      attr_reader members: Array[method_member]
+
+      # The original method when the method is defined with `alias` syntax
+      attr_reader alias_of: Method?
+
+      # Present if the method is defined with `alias` syntax
+      attr_reader alias_member: AST::Members::Alias?
+
+      # Unused, always returns empty array
+      %a{deprecated} attr_reader extra_annotations: Array[AST::Annotation]
+
+      # Union of annotations given to `def`s and `alias`, not contains annotations given to each overload
+      #
+      # The elements will be updated during `Method` object setup.
+      #
+      attr_reader annotations: Array[AST::Annotation]
+
+      # Note that the annotations given through `annotations:` keyword is ignored.
+      #
+      def initialize: (
+          super_method: Method?,
+          defs: Array[TypeDef],
+          accessibility: accessibility,
+          alias_of: Method?,
+          alias_member: AST::Members::Alias?
+        ) -> void
+      | %a{deprecated} (
+          super_method: Method?,
+          defs: Array[TypeDef],
+          accessibility: accessibility,
+          alias_of: Method?,
+          annotations: Array[AST::Annotation]
+        ) -> void
+
+      def public?: () -> bool
+
+      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: () { (Types::t) -> Types::t } -> Method
+
+      def map_method_type: () { (MethodType) -> MethodType } -> Method
+
+      def update: (
+        ?super_method: Method?,
+        ?defs: Array[TypeDef],
+        ?accessibility: accessibility,
+        ?alias_of: Method?,
+        ?annotations: Array[AST::Annotation],
+        ?alias_member: AST::Members::Alias?
+      ) -> Method
+    end
+
+    module Ancestor
+      type t = Instance | Singleton
+
+      class Instance
+        type source = :super     # Inheritance
+                    | nil        # Itself
+                    | AST::Members::Include | AST::Members::Extend | AST::Members::Prepend  # AST
+                    | AST::Ruby::Members::IncludeMember | AST::Ruby::Members::ExtendMember | AST::Ruby::Members::PrependMember  # Ruby AST
+                    | AST::Declarations::Module::Self
+
+        attr_reader name: TypeName
+        attr_reader args: Array[Types::t]
+        attr_reader source: source
+
+        def initialize: (name: TypeName, args: Array[Types::t], source: source) -> 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], env: Environment, location: Location[untyped, untyped]?) -> 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::InterfaceEntry
+
+    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: () -> Array[AST::TypeParam]
+
+    def sub: (Substitution) -> Definition
+
+    def map_method_type: () { (MethodType) -> MethodType } -> Definition
+
+    def each_type: () { (Types::t) -> void } -> void
+                 | () -> Enumerator[Types::t, void]
+  end
+end

data/sig/definition_builder.rbs

@@ -0,0 +1,181 @@
+module RBS
+  # DefinitionBuilder translates TypeName to Definition of the type
+  #
+  # It also provides semantic utilities that depends on Environment.
+  #
+  class DefinitionBuilder
+    attr_reader env: Environment
+    attr_reader ancestor_builder: AncestorBuilder
+    attr_reader method_builder: MethodBuilder
+
+    attr_reader instance_cache: Hash[TypeName, Definition | false | nil]
+    attr_reader singleton_cache: Hash[TypeName, Definition | false | nil]
+    attr_reader singleton0_cache: Hash[TypeName, Definition | false | nil]
+    attr_reader interface_cache: Hash[TypeName, Definition | false | nil]
+
+    def initialize: (env: Environment, ?ancestor_builder: AncestorBuilder?, ?method_builder: MethodBuilder?) -> void
+
+    # Returns a Definition of a interface
+    #
+    def build_interface: (TypeName) -> Definition
+
+    # Returns a Definition of an instance type
+    #
+    # If TypeName is a module and `no_self_types` is `true`, it won't have methods of _self type constraints_.
+    # This typically happens when definition is being calculated for mixin.
+    #
+    def build_instance: (TypeName) -> Definition
+
+    # Returns a Definition of a singleton type
+    def build_singleton: (TypeName) -> Definition
+
+    # Validates the given Namespace and its ancestor namespaces exists
+    #
+    # Raises NoTypeFoundError
+    #
+    def ensure_namespace!: (Namespace, location: 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
+
+    # Validates presence of type names recursively
+    #
+    # Assumes the type names are already resolved.
+    # Raises NoTypeFoundError in case of failure.
+    #
+    # Normalizes type names in the given type automatically.
+    #
+    def validate_type_presence: (Types::t) -> void
+
+    # Validates presence of an absolute type name
+    #
+    # Raises NoTypeFoundError in case of error.
+    #
+    # Normalizes the given type name automatically.
+    #
+    def validate_type_name: (TypeName, Location[untyped, untyped]?) -> void
+
+    # Returns a new DefinitionBuilder with updated Environment, AncestorBuilder, and exceptions
+    #
+    def update: (env: Environment, ancestor_builder: AncestorBuilder, except: _Each[TypeName]) -> DefinitionBuilder
+
+    private
+
+    def validate_super_class!: (TypeName, Environment::ClassEntry) -> void
+
+    def build_singleton0: (TypeName) -> Definition
+
+    # Returns `interface_methods` from given array of interface ancestors
+    #
+    def interface_methods: (Array[Definition::Ancestor::Instance] interface_ancestors) -> interface_methods
+
+    def special_accessibility: (bool, Symbol) -> Definition::accessibility?
+
+    def try_cache: (TypeName, cache: Hash[TypeName, Definition | false | nil]) { () -> Definition } -> Definition
+
+    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
+
+    def source_location: (Definition::Ancestor::Instance::source, AST::Declarations::t | AST::Ruby::Declarations::t) -> Location[untyped, untyped]?
+
+    def validate_variable: (Definition::Variable) -> void
+
+    def insert_variable: (
+      TypeName,
+      Hash[Symbol, Definition::Variable],
+      name: Symbol,
+      type: Types::t,
+      source: Definition::Variable::source
+    ) -> void
+
+    # Add method definition to `methods`, which will be merged to `class_definition` after defining all methods at this *level* -- class, module, or interface
+    #
+    # `class_definition` is a definition of given type, but it has definitions of prior levels.
+    #
+    def define_method: (
+      Hash[Symbol, Definition::Method] methods,
+      Definition class_definition,
+      MethodBuilder::Methods::Definition method_definition,
+      Substitution subst,
+      Hash[Symbol, Definition::Method]? self_type_methods,
+      defined_in: TypeName,
+      ?implemented_in: TypeName?
+    ) -> void
+
+    # The `interface_methods` type describes the association between the interface name to its name and the *mixin* to a module
+    #
+    type interface_methods = Hash[
+      Definition::Ancestor::Instance,
+      [MethodBuilder::Methods, AST::Members::Include | AST::Members::Extend]
+    ]
+
+    # Add method definitions from `module_methods` to `definition`
+    #
+    # It also processes interface mixins, with duplication detection.
+    # It doesn't process module mixins.
+    #
+    def import_methods: (
+      Definition definition,
+      TypeName module_name,
+      MethodBuilder::Methods module_methods,
+      interface_methods interface_methods,
+      Substitution subst,
+      Hash[Symbol, Definition::Method]? self_type_methods,
+    ) -> void
+
+    # Updates `definition` with methods and instance variables of `type_name` that can be a module or a class
+    #
+    # It processes includes and prepends recursively.
+    # If `define_class_vars:` is falsy, it skips inserting class variables.
+    #
+    def define_instance: (
+      Definition definition,
+      TypeName type_name,
+      Substitution subst,
+      define_class_vars: bool
+    ) -> void
+
+    # Updates `definition` with methods defined in an interface `type_name`
+    #
+    # It processes includes recursively
+    #
+    def define_interface: (Definition definition, TypeName type_name, Substitution subst) -> void
+
+    # Returns a substitution that corresponds to type application
+    #
+    # ```
+    # tapp_subst(`::Array`, [`::Integer`]) # => Substitution.build([:Elem], [`::Integer`])
+    # ```
+    #
+    def tapp_subst: (TypeName, Array[Types::t]) -> Substitution
+  end
+end