rbs 0.11.0 → 0.12.0

data/sig/definition_builder.rbs

@@ -0,0 +1,95 @@
+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,4 @@
+module RBS
+  class EnvironmentLoader
+  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

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