rbs 0.18.1 → 1.0.0.pre2

data/sig/definition.rbs

@@ -65,10 +65,15 @@ module RBS
       type t = Instance | Singleton
 
       class Instance
+        type source = :super | nil
+                    | AST::Members::Include | AST::Members::Extend | AST::Members::Prepend
+                    | 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]) -> void
+        def initialize: (name: TypeName, args: Array[Types::t], source: source) -> void
       end
 
       class Singleton

data/sig/definition_builder.rbs

@@ -1,97 +1,45 @@
 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 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]
 
-    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_singleton: (TypeName) -> Definition
+    def build_interface: (TypeName) -> Definition
 
     def build_instance: (TypeName) -> Definition
 
-    def build_interface: (TypeName) -> Definition
+    def build_singleton0: (TypeName) -> Definition
 
-    def build_one_instance: (TypeName) -> Definition
-
-    def build_one_singleton: (TypeName) -> Definition
+    def build_singleton: (TypeName) -> Definition
 
-    type ancestors = Definition::InstanceAncestors | Definition::SingletonAncestors | nil
-    def merge_definitions: (TypeName,
-                            Array[[Definition::Ancestor::t, Definition]],
-                            entry: Environment::ModuleEntry | Environment::ClassEntry,
-                            self_type: Definition::self_type,
-                            ancestors: ancestors) -> Definition
+    def merge_definition: (src: Definition, dest: Definition, subst: Substitution, ?implemented_in: :keep | TypeName | nil, ?keep_super: bool) -> void
 
-    type method_kind = :instance | :singleton
-    def merge_method: (TypeName, Hash[Symbol, Definition::Method], Symbol, Definition::Method, Substitution, kind: method_kind) -> void
+    def merge_method: (TypeName, Hash[Symbol, Definition::Method], Symbol, Definition::Method, Substitution, ?implemented_in: :keep | TypeName | nil, ?keep_super: bool) -> void
 
-    def merge_variable: (Hash[Symbol, Definition::Variable], Symbol, Definition::Variable) -> void
+    def merge_variable: (Hash[Symbol, Definition::Variable], Symbol, Definition::Variable, Substitution, ?keep_super: bool) -> 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 validate_type_params: (Definition, ancestors: AncestorBuilder::OneAncestors, methods: MethodBuilder::Methods) -> void
+
+    def source_location: (Definition::Ancestor::Instance::source, AST::Declarations::t) -> Location?
+
+    def insert_variable: (TypeName, Hash[Symbol, Definition::Variable], name: Symbol, type: Types::t) -> void
 
-    def expand_alias: (TypeName) -> Types::t
+    def define_methods: (Definition, interface_methods: Hash[Symbol, Definition::Method], methods: MethodBuilder::Methods, super_interface_method: bool) -> void
   end
 end

data/sig/errors.rbs

@@ -0,0 +1,159 @@
+module RBS
+  interface _MethodName
+    def kind: () -> (:instance | :singleton)
+
+    def type_name: () -> TypeName
+
+    def method_name: () -> Symbol
+  end
+
+  module MethodNameHelper : _MethodName
+    def method_name_string: () -> String
+  end
+
+  class InvalidTypeApplicationError < StandardError
+    attr_reader type_name: TypeName
+    attr_reader args: Array[Types::t]
+    attr_reader params: Array[Symbol]
+    attr_reader location: Location?
+
+    def initialize: (type_name: TypeName, args: Array[Types::t], params: Array[Symbol], location: Location?) -> void
+
+    def self.check!: (type_name: TypeName, args: Array[Types::t], params: Array[Symbol], location: Location?) -> void
+  end
+
+  class RecursiveAncestorError < StandardError
+    attr_reader ancestors: Array[Definition::Ancestor::t]
+    attr_reader location: Location
+
+    def initialize: (ancestors: Array[Definition::Ancestor::t], location: Location?) -> void
+
+    def self.check!: (Definition::Ancestor::t, ancestors: Array[Definition::Ancestor::t], location: Location?) -> void
+  end
+
+  class NoTypeFoundError < StandardError
+    attr_reader type_name: TypeName
+    attr_reader location: Location?
+
+    def initialize: (type_name: TypeName, location: Location?) -> void
+
+    def self.check!: (TypeName, env: Environment, location: Location?) -> TypeName
+  end
+
+  class NoSuperclassFoundError < StandardError
+    attr_reader type_name: TypeName
+    attr_reader location: Location?
+
+    def initialize: (type_name: TypeName, location: Location?) -> void
+
+    def self.check!: (TypeName, env: Environment, location: Location?) -> void
+  end
+
+  class NoSelfTypeFoundError < StandardError
+    attr_reader type_name: TypeName
+    attr_reader location: Location?
+
+    def initialize: (type_name: TypeName, location: Location?) -> void
+
+    def self.check!: (AST::Declarations::Module::Self, env: Environment) -> void
+  end
+
+  class NoMixinFoundError < StandardError
+    attr_reader type_name: TypeName
+    attr_reader member: AST::Members::t
+
+    def initialize: (type_name: TypeName, member: AST::Members::t) -> void
+
+    def location: () -> Location?
+
+    def self.check!: (TypeName, env: Environment, member: AST::Members::t) -> void
+  end
+
+  class DuplicatedMethodDefinitionError < StandardError
+    type ty = Types::ClassSingleton | Types::ClassInstance | Types::Interface
+    type original = DefinitionBuilder::MethodBuilder::Methods::Definition::original
+
+    attr_reader type: ty
+    attr_reader method_name: Symbol
+    attr_reader members: Array[original]
+
+    def initialize: (type: ty, method_name: Symbol, members: Array[original]) -> void
+
+    def qualified_method_name: () -> String
+
+    def location: () -> Location?
+
+    def other_locations: () -> Array[Location?]
+  end
+
+  class DuplicatedInterfaceMethodDefinitionError < StandardError
+    type ty = Types::ClassSingleton | Types::ClassInstance | Types::Interface
+    type mixin_member = AST::Members::Include | AST::Members::Extend
+
+    attr_reader type: ty
+    attr_reader method_name: Symbol
+    attr_reader member: mixin_member
+
+    def initialize: (type: ty, method_name: Symbol, member: mixin_member) -> void
+
+    def qualified_method_name: () -> String
+  end
+
+  class UnknownMethodAliasError < StandardError
+    attr_reader original_name: Symbol
+    attr_reader aliased_name: Symbol
+    attr_reader location: Location?
+
+    def initialize: (original_name: Symbol, aliased_name: Symbol, location: Location?) -> void
+  end
+
+  class SuperclassMismatchError < StandardError
+    attr_reader name: TypeName
+    attr_reader entry: Environment::ClassEntry
+
+    def initialize: (name: TypeName, entry: Environment::ClassEntry) -> void
+  end
+
+  class InvalidOverloadMethodError < StandardError
+    attr_reader type_name: TypeName
+    attr_reader method_name: Symbol
+    attr_reader kind: :instance | :singleton
+    attr_reader members: Array[AST::Members::MethodDefinition]
+
+    def initialize: (type_name: TypeName, method_name: Symbol, kind: :instance | :singleton, members: Array[AST::Members::MethodDefinition]) -> void
+  end
+
+  class GenericParameterMismatchError < StandardError
+    attr_reader name: TypeName
+    attr_reader decl: AST::Declarations::Class | AST::Declarations::Module
+
+    def initialize: (name: TypeName, decl: AST::Declarations::Class | AST::Declarations::Module) -> void
+  end
+
+  class DuplicatedDeclarationError < StandardError
+    attr_reader name: TypeName | Symbol
+    attr_reader decls: Array[AST::Declarations::t]
+
+    def initialize: (TypeName | Symbol, *AST::Declarations::t) -> void
+  end
+
+  class InvalidVarianceAnnotationError < StandardError
+    attr_reader type_name: TypeName
+    attr_reader param: AST::Declarations::ModuleTypeParams::TypeParam
+    attr_reader location: Location?
+
+    def initialize: (type_name: TypeName, param: AST::Declarations::ModuleTypeParams::TypeParam, location: Location?) -> void
+  end
+
+  class RecursiveAliasDefinitionError < StandardError
+    type ty = Types::ClassInstance | Types::ClassSingleton | Types::Interface
+    type defn = DefinitionBuilder::MethodBuilder::Methods::Definition
+
+    attr_reader type: ty
+    attr_reader defs: Array[defn]
+
+    def initialize: (type: ty, defs: Array[defn]) -> void
+
+    def location: () -> Location?
+  end
+end

data/sig/members.rbs

@@ -91,14 +91,17 @@ module RBS
       end
 
       module Attribute
+        type kind = :instance | :singleton
+
         attr_reader name: Symbol
         attr_reader type: Types::t
+        attr_reader kind: kind
         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
+        def initialize: (name: Symbol, type: Types::t, ivar_name: Symbol | false | nil, kind: kind, annotations: Array[Annotation], location: Location?, comment: Comment?) -> void
 
         include _HashEqual
       end

data/sig/method_builder.rbs

@@ -0,0 +1,71 @@
+module RBS
+  class DefinitionBuilder
+    class MethodBuilder
+      class Methods
+        type instance_type = Types::ClassInstance | Types::ClassSingleton | Types::Interface
+
+        class Definition
+          type original = AST::Members::MethodDefinition | AST::Members::Alias | AST::Members::AttrAccessor | AST::Members::AttrWriter | AST::Members::AttrReader
+          type accessibility = :public | :private
+
+          attr_reader name: Symbol
+          attr_reader type: instance_type
+          attr_reader originals: Array[original]
+          attr_reader overloads: Array[AST::Members::MethodDefinition]
+          attr_reader accessibilities: Array[accessibility]
+
+          def initialize: (name: Symbol, type: instance_type, originals: Array[original], overloads: Array[AST::Members::MethodDefinition], accessibilities: Array[accessibility]) -> void
+
+          def original: () -> original?
+
+          def accessibility: () -> accessibility
+
+          def self.empty: (name: Symbol, type: instance_type) -> instance
+        end
+
+        attr_reader type: instance_type
+        attr_reader methods: Hash[Symbol, Definition]
+
+        def initialize: (type: instance_type) -> void
+
+        def validate!: () -> self
+
+        def each: () { (Definition) -> void } -> void
+                | () -> Enumerator[Definition, void]
+
+        class Sorter
+          include TSort[Definition]
+
+          attr_reader methods: Hash[Symbol, Definition]
+
+          def initialize: (Hash[Symbol, Definition]) -> void
+
+          def tsort_each_node: { (Definition) -> void } -> void
+
+          def tsort_each_child: (Definition) { (Definition) -> void } -> void
+        end
+      end
+
+      attr_reader env: Environment
+      attr_reader instance_methods: Hash[TypeName, Methods]
+      attr_reader singleton_methods: Hash[TypeName, Methods]
+      attr_reader interface_methods: Hash[TypeName, Methods]
+
+      def initialize: (env: Environment) -> void
+
+      def build_instance: (TypeName) -> Methods
+
+      def build_singleton: (TypeName) -> Methods
+
+      def build_interface: (TypeName) -> Methods
+
+      def build_alias: (Methods, Methods::instance_type, member: AST::Members::Alias, accessibility: Methods::Definition::accessibility) -> void
+
+      def build_attribute: (Methods, Methods::instance_type, member: AST::Members::AttrAccessor | AST::Members::AttrReader | AST::Members::AttrWriter, accessibility: Methods::Definition::accessibility) -> void
+
+      def build_method: (Methods, Methods::instance_type, member: AST::Members::MethodDefinition, accessibility: Methods::Definition::accessibility) -> 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
+    end
+  end
+end

data/sig/method_types.rbs

@@ -1,24 +1,11 @@
 module RBS
   class MethodType
-    class Block
-      attr_reader type: Types::Function
-      attr_reader required: bool
-
-      def initialize: (type: Types::Function, required: boolish) -> 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 block: Types::Block?
     attr_reader location: Location?
 
-    def initialize: (type_params: Array[Symbol], type: Types::Function, block: Block?, location: Location?) -> void
+    def initialize: (type_params: Array[Symbol], type: Types::Function, block: Types::Block?, location: Location?) -> void
 
     def ==: (untyped other) -> bool
 
@@ -26,7 +13,7 @@ module RBS
 
     def sub: (Substitution) -> MethodType
 
-    def update: (?type_params: Array[Symbol], ?type: Types::Function, ?block: Block?, ?location: Location?) -> MethodType
+    def update: (?type_params: Array[Symbol], ?type: Types::Function, ?block: Types::Block?, ?location: Location?) -> MethodType
 
     def free_variables: (?Set[Symbol] set) -> Set[Symbol]
 

data/sig/substitution.rbs

@@ -35,5 +35,8 @@ module RBS
 
     # Returns a substitution without variables given in `vars`.
     def without: (*Symbol vars) -> Substitution
+
+    # Returns true if given substitution is identity.
+    def empty?: () -> bool
   end
 end

data/sig/type_name_resolver.rbs

@@ -1,10 +1,12 @@
 module RBS
   class TypeNameResolver
+    type context = Array[Namespace]
+
     class Query
       attr_reader type_name: TypeName
       attr_reader context: Array[Namespace]
 
-      def initialize: (type_name: TypeName, context: Array[Namespace]) -> void
+      def initialize: (type_name: TypeName, context: context) -> void
     end
 
     attr_reader all_names: Set[TypeName]
@@ -15,7 +17,7 @@ module RBS
 
     def add_names: (Array[TypeName]) -> self
 
-    def resolve: (TypeName, context: Array[Namespace]) -> TypeName?
+    def resolve: (TypeName, context: context) -> TypeName?
 
     def has_name?: (TypeName) -> TypeName?