rbs 0.11.0 → 0.13.1

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

data/sig/definition_builder.rbs

@@ -0,0 +1,94 @@
+module RBS
+  class DefinitionBuilder
+    class OneAncestors
+      attr_reader type_name: TypeName
+      attr_reader params: Array[Symbol]?
+      attr_reader super_class: Definition::Ancestor::t?
+      attr_reader self_types: Array[Definition::Ancestor::Instance]?
+      attr_reader included_modules: Array[Definition::Ancestor::Instance]?
+      attr_reader prepended_modules: Array[Definition::Ancestor::Instance]?
+      attr_reader extended_modules: Array[Definition::Ancestor::Instance]?
+
+      def initialize: (type_name: TypeName,
+                          params: Array[Symbol]?,
+                     super_class: Definition::Ancestor::t?,
+                      self_types: Array[Definition::Ancestor::Instance]?,
+                included_modules: Array[Definition::Ancestor::Instance]?,
+               prepended_modules: Array[Definition::Ancestor::Instance]?,
+                extended_modules: Array[Definition::Ancestor::Instance]?) -> void
+
+      def each_ancestor: { (Definition::Ancestor::t) -> void } -> void
+                       | -> Enumerator[Definition::Ancestor::t, void]
+
+      def self.class_instance: (type_name: TypeName, params: Array[Symbol], super_class: Definition::Ancestor::t?) -> instance
+
+      def self.singleton: (type_name: TypeName, super_class: Definition::Ancestor::t?) -> instance
+
+      def self.module_instance: (type_name: TypeName, params: Array[Symbol]) -> instance
+    end
+
+    attr_reader env: Environment
+    attr_reader type_name_resolver: TypeNameResolver
+
+    attr_reader instance_cache: Hash[TypeName, Definition | false | nil]
+    attr_reader singleton_cache: Hash[TypeName, Definition | false | nil]
+    attr_reader interface_cache: Hash[TypeName, Definition | false | nil]
+
+    attr_reader one_instance_cache: Hash[TypeName, Definition]
+    attr_reader one_singleton_cache: Hash[TypeName, Definition]
+
+    attr_reader instance_ancestors_cache: Hash[TypeName, Definition::InstanceAncestors]
+    attr_reader singleton_ancestor_cache: Hash[TypeName, Definition::SingletonAncestors]
+
+    attr_reader one_instance_ancestors_cache: Hash[TypeName, OneAncestors]
+    attr_reader one_singleton_ancestors_cache: Hash[TypeName, OneAncestors]
+
+    def initialize: (env: Environment) -> void
+
+    def validate_super_class!: (TypeName, Environment::ClassEntry) -> void
+
+    def one_instance_ancestors: (TypeName) -> OneAncestors
+
+    def one_singleton_ancestors: (TypeName) -> OneAncestors
+
+    def instance_ancestors: (TypeName, ?building_ancestors: Array[Definition::Ancestor::t]) -> Definition::InstanceAncestors
+
+    def singleton_ancestors: (TypeName, ?building_ancestors: Array[Definition::Ancestor::t]) -> Definition::SingletonAncestors
+
+    def mixin_ancestors: (Environment::ClassEntry | Environment::ModuleEntry, included_modules: Array[Definition::Ancestor::Instance]?, prepended_modules: Array[Definition::Ancestor::Instance]?, extended_modules: Array[Definition::Ancestor::Instance]?) -> void
+
+    def each_member_with_accessibility: (Array[AST::Members::t | AST::Declarations::t], ?accessibility: Definition::accessibility) { (AST::Members::t | AST::Declarations::t, Definition::accessibility) -> void } -> void
+
+    def ensure_namespace!: (Namespace, location: Location?) -> void
+
+    def build_instance: (TypeName) -> Definition
+
+    def build_interface: (TypeName) -> Definition
+
+    def build_one_instance: (TypeName) -> Definition
+
+    def build_one_singleton: (TypeName) -> Definition
+
+    def merge_definitions: (TypeName,
+                            Array[[Definition::Ancestor::t, Definition]],
+                            entry: Environment::ModuleEntry | Environment::ClassEntry,
+                            self_type: Definition::self_type,
+                            ancestors: Array[Definition::Ancestor::t]) -> Definition
+
+    type method_kind = :instance | :singleton
+    def merge_method: (TypeName, Hash[Symbol, Definition::Method], Symbol, Definition::Method, Substitution, kind: method_kind) -> void
+
+    def merge_variable: (Hash[Symbol, Definition::Variable], Symbol, Definition::Variable) -> void
+
+    def try_cache: (TypeName, cache: Hash[TypeName, Definition | false | nil]) { () -> Definition } -> Definition
+
+    type member_detail = [Definition::accessibility, Definition::Method?, AST::Members::MethodDefinition?, Array[AST::Members::MethodDefinition]]
+    def method_definition_members: (TypeName, Environment::ClassEntry | Environment::ModuleEntry, kind: :singleton | :instance) -> Hash[Symbol, member_detail]
+
+    def validate_params_with: (AST::Declarations::ModuleTypeParams, result: VarianceCalculator::Result) { (AST::Declarations::ModuleTypeParams::TypeParam) -> void } -> void
+
+    def validate_parameter_variance: (decl: AST::Declarations::Class | AST::Declarations::Module | AST::Declarations::Interface, methods: Hash[Symbol, Definition::Method]) -> void
+
+    def expand_alias: (TypeName) -> Types::t
+  end
+end

data/sig/environment.rbs

@@ -0,0 +1,94 @@
+module RBS
+  class Environment
+    type module_decl = AST::Declarations::Class | AST::Declarations::Module
+
+    interface _WithContext
+      def outer: () -> Array[module_decl]
+
+      def decl: () -> module_decl
+    end
+
+    module ContextUtil : _WithContext
+      def context: () -> Array[Namespace]
+    end
+
+    class MultiEntry
+      class D[M]
+        attr_reader decl: M
+        attr_reader outer: Array[module_decl]
+
+        def initialize: (decl: module_decl, outer: Array[module_decl]) -> void
+
+        include ContextUtil
+      end
+
+      attr_reader name: TypeName
+      attr_reader decls: Array[D[module_decl]]
+
+      def initialize: (name: TypeName) -> void
+
+      def insert: (decl: module_decl, outer: Array[module_decl]) -> void
+
+      def validate_type_params: () -> void
+
+      def type_params: () -> AST::Declarations::ModuleTypeParams
+
+      def primary: () -> D[module_decl]
+    end
+
+    class ModuleEntry < MultiEntry
+      attr_reader decls: Array[MultiEntry::D[AST::Declarations::Module]]
+      attr_reader primary: MultiEntry::D[AST::Declarations::Module]
+
+      def self_types: () -> Array[AST::Declarations::Module::Self]
+    end
+
+    class ClassEntry < MultiEntry
+      attr_reader decls: Array[MultiEntry::D[AST::Declarations::Class]]
+      attr_reader primary: MultiEntry::D[AST::Declarations::Class]
+    end
+
+    class SingleEntry[N, D]
+      include ContextUtil
+
+      attr_reader name: N
+      attr_reader decl: D
+      attr_reader outer: Array[module_decl]
+
+      def initialize: (name: N, decl: D, outer: Array[module_decl]) -> void
+    end
+
+    attr_reader buffers: Array[Buffer]
+    attr_reader declarations: Array[AST::Declarations::t]
+
+    attr_reader class_decls: Hash[TypeName, ModuleEntry | ClassEntry]
+    attr_reader interface_decls: Hash[TypeName, SingleEntry[TypeName, AST::Declarations::Interface]]
+    attr_reader alias_decls: Hash[TypeName, SingleEntry[TypeName, AST::Declarations::Alias]]
+    attr_reader constant_decls: Hash[TypeName, SingleEntry[TypeName, AST::Declarations::Constant]]
+    attr_reader global_decls: Hash[Symbol, SingleEntry[Symbol, AST::Declarations::Global]]
+
+    def initialize: () -> void
+
+    def initialize_copy: (Environment) -> void
+
+    def self.from_loader: (EnvironmentLoader) -> Environment
+
+    def cache_name: [Key, D] (Hash[Key, SingleEntry[Key, D]] cache, name: Key, decl: D, outer: Array[module_decl]) -> SingleEntry[Key, D]
+
+    def insert_decl: (AST::Declarations::t, outer: Array[module_decl], namespace: Namespace) -> void
+
+    def <<: (AST::Declarations::t decl) -> self
+
+    def resolve_type_names: () -> Environment
+
+    def resolve_declaration: (TypeNameResolver resolver, AST::Declarations::t decl, outer: Array[module_decl], prefix: Namespace) -> AST::Declarations::t
+
+    def resolve_member: (TypeNameResolver, AST::Members::t, context: Array[Namespace]) -> AST::Members::t
+
+    def absolute_type: (TypeNameResolver, Types::t, context: Array[Namespace]) -> Types::t
+
+    def absolute_type_name: (TypeNameResolver, TypeName, context: Array[Namespace]) -> TypeName
+
+    def inspect: () -> String
+  end
+end

data/sig/environment_loader.rbs

@@ -0,0 +1,58 @@
+module RBS
+  class EnvironmentLoader
+    class UnknownLibraryNameError < StandardError
+      attr_reader name: String
+
+      def initialize: (name: String) -> void
+    end
+
+    class LibraryPath
+      attr_reader name: String
+      attr_reader path: Pathname
+
+      def initialize: (name: String, path: Pathname) -> void
+    end
+
+    class GemPath
+      attr_reader name: String
+      attr_reader version: String?
+      attr_reader path: Pathname
+
+      def initialize: (name: String, version: String?, path: Pathname) -> void
+    end
+
+    STDLIB_ROOT: Pathname
+
+    type path = Pathname | LibraryPath | GemPath
+
+    attr_reader paths: Array[path]
+    attr_reader stdlib_root: Pathname
+    attr_reader gem_vendor_path: Pathname?
+
+    def self.gem_sig_path: (String, String?) -> Pathname?
+
+    def initialize: (?stdlib_root: Pathname, ?gem_vendor_path: Pathname?) -> void
+
+    def add: (path: Pathname?) -> void
+           | (library: String?) -> void
+
+    def self.parse_library: (String) -> [String, String?]
+
+    def stdlib?: (String) -> Pathname?
+
+    def gem?: (String, String?) -> Pathname?
+
+    def each_signature: (Pathname, ?immediate: bool) { (Pathname) -> void } -> void
+                      | (Pathname, ?immediate: bool) -> Enumerator[Pathname, void]
+
+    def each_library_path: { (path, Pathname) -> void } -> void
+
+    def no_builtin!: (?bool) -> self
+
+    def no_builtin?: () -> bool
+
+    def each_decl: () { (AST::Declarations::t, Buffer, Pathname, path | :stdlib) -> void } -> void
+
+    def load: (env: Environment) -> Array[[AST::Declarations::t, Pathname, path | :stdlib]]
+  end
+end

data/sig/location.rbs

@@ -0,0 +1,52 @@
+module RBS
+  # Location is the range on buffer, `start_pos..end_pos`.
+  # The index is based on characters.
+  class Location
+    # The buffer this location points on.
+    attr_reader buffer: Buffer
+
+    # The index of character the range starts from.
+    attr_reader start_pos: Integer
+
+    # The index of character the range ends at.
+    attr_reader end_pos: Integer
+
+    def initialize: (buffer: Buffer, start_pos: Integer, end_pos: Integer) -> void
+
+    def inspect: () -> ::String
+
+    def name: () -> untyped
+
+    def start_line: () -> Integer
+
+    def start_column: () -> Integer
+
+    def end_line: () -> Integer
+
+    def end_column: () -> Integer
+
+    def start_loc: () -> Buffer::loc
+
+    def end_loc: () -> Buffer::loc
+
+    def source: () -> String
+
+    def to_s: () -> String
+
+    def self.to_string: (Location? location, ?default: ::String default) -> String
+
+    def ==: (untyped other) -> bool
+
+    def +: (Location other) -> Location
+
+    def pred?: (Location loc) -> bool
+
+    def to_json: (*untyped args) -> untyped
+
+    # `<<` locations given as argument.
+    def concat: (*Location?) -> Location
+
+    # Append given location destructively.
+    def <<: (Location?) -> Location
+  end
+end

data/sig/members.rbs

@@ -0,0 +1,160 @@
+module RBS
+  module AST
+    module Members
+      type t = MethodDefinition
+             | InstanceVariable | ClassInstanceVariable | ClassVariable
+             | Include | Extend | Prepend
+             | AttrReader | AttrWriter | AttrAccessor
+             | Public | Private
+             | Alias
+
+      # Base class for members.
+      class Base
+      end
+
+      class MethodDefinition < Base
+        type kind = :instance | :singleton | :singleton_instance
+
+        attr_reader name: Symbol
+        attr_reader kind: kind
+        attr_reader types: Array[MethodType]
+        attr_reader annotations: Array[Annotation]
+        attr_reader location: Location?
+        attr_reader comment: Comment?
+        attr_reader overload: bool
+
+        def initialize: (name: Symbol, kind: kind, types: Array[MethodType], annotations: Array[Annotation], location: Location?, comment: Comment?, overload: bool) -> void
+
+        include _HashEqual
+        include _ToJson
+
+        def instance?: () -> bool
+
+        def singleton?: () -> bool
+
+        def overload?: () -> bool
+
+        def update: (?name: Symbol, ?kind: kind, ?types: Array[MethodType], ?annotations: Array[Annotation], ?location: Location?, ?comment: Comment?, ?overload: bool) -> MethodDefinition
+      end
+
+      module Var
+        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
+      end
+
+      class InstanceVariable < Base
+        include Var
+        include _ToJson
+      end
+
+      class ClassInstanceVariable < Base
+        include Var
+        include _ToJson
+      end
+
+      class ClassVariable < Base
+        include Var
+        include _ToJson
+      end
+
+      module Mixin
+        attr_reader name: TypeName
+        attr_reader args: Array[Types::t]
+        attr_reader annotations: Array[Annotation]
+        attr_reader location: Location?
+        attr_reader comment: Comment?
+
+        def initialize: (name: TypeName, args: Array[Types::t], annotations: Array[Annotation], location: Location?, comment: Comment?) -> void
+
+        include _HashEqual
+      end
+
+      class Include < Base
+        include Mixin
+        include _ToJson
+      end
+
+      class Extend < Base
+        include Mixin
+        include _ToJson
+      end
+
+      class Prepend < Base
+        include Mixin
+        include _ToJson
+      end
+
+      module Attribute
+        attr_reader name: Symbol
+        attr_reader type: Types::t
+        attr_reader ivar_name: Symbol | false | nil
+        attr_reader annotations: Array[Annotation]
+        attr_reader location: Location?
+        attr_reader comment: Comment?
+
+        def initialize: (name: Symbol, type: Types::t, ivar_name: Symbol | false | nil, annotations: Array[Annotation], location: Location?, comment: Comment?) -> void
+
+        include _HashEqual
+      end
+
+      class AttrReader < Base
+        include Attribute
+        include _ToJson
+      end
+
+      class AttrAccessor < Base
+        include Attribute
+        include _ToJson
+      end
+
+      class AttrWriter < Base
+        include Attribute
+        include _ToJson
+      end
+
+      module LocationOnly
+        attr_reader location: Location?
+
+        def initialize: (location: Location?) -> void
+
+        include _HashEqual
+      end
+
+      class Public < Base
+        include LocationOnly
+        include _ToJson
+      end
+
+      class Private < Base
+        include LocationOnly
+        include _ToJson
+      end
+
+      class Alias < Base
+        type kind = :instance | :singleton
+
+        attr_reader new_name: Symbol
+        attr_reader old_name: Symbol
+        attr_reader kind: kind
+        attr_reader annotations: Array[Annotation]
+        attr_reader location: Location?
+        attr_reader comment: Comment?
+
+        def initialize: (new_name: Symbol, old_name: Symbol, kind: kind, annotations: Array[Annotation], location: Location?, comment: Comment?) -> void
+
+        include _HashEqual
+        include _ToJson
+
+        def instance?: () -> bool
+
+        def singleton?: () -> bool
+      end
+    end
+  end
+end