rbs 2.8.4 → 3.8.1

data/sig/definition.rbs

@@ -21,11 +21,18 @@ module RBS
         attr_reader defined_in: TypeName
         attr_reader implemented_in: TypeName?
 
-        def initialize: (type: MethodType, member: method_member, defined_in: TypeName, implemented_in: TypeName?) -> void
+        # Annotations given to `#member`
+        attr_reader member_annotations: Array[AST::Annotation]
 
-        def comment: () -> AST::Comment?
+        # Annotations given to the overload associated to the method type
+        attr_reader overload_annotations: Array[AST::Annotation]
+
+        # Concatenation of `member_annotations` and `overload_annotations`
+        attr_reader annotations: Array[AST::Annotation]
 
-        def annotations: () -> Array[AST::Annotation]
+        def initialize: (type: MethodType, member: method_member, defined_in: TypeName, implemented_in: TypeName?, ?overload_annotations: Array[AST::Annotation]) -> void
+
+        def comment: () -> AST::Comment?
 
         def update: (?type: MethodType, ?member: method_member, ?defined_in: TypeName, ?implemented_in: TypeName?) -> TypeDef
 
@@ -35,15 +42,23 @@ module RBS
       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]
       attr_reader alias_of: Method?
 
+      # Unused, always returns empty array
+      attr_reader extra_annotations: Array[AST::Annotation]
+
+      # Union of annotations given to `defs`, not contains annotations given to each overload
+      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,
@@ -66,7 +81,7 @@ module RBS
       #
       def map_type: () { (Types::t) -> Types::t } -> Method
 
-      def map_type_bound: () { (AST::TypeParam::bound) -> AST::TypeParam::bound } -> Method
+      def map_type_bound: () { (Types::t) -> Types::t } -> Method
 
       def map_method_type: () { (MethodType) -> MethodType } -> Method
 
@@ -83,8 +98,9 @@ module RBS
       type t = Instance | Singleton
 
       class Instance
-        type source = :super | nil
-                    | AST::Members::Include | AST::Members::Extend | AST::Members::Prepend
+        type source = :super     # Inheritance
+                    | nil        # Itself
+                    | AST::Members::Include | AST::Members::Extend | AST::Members::Prepend  # AST
                     | AST::Declarations::Module::Self
 
         attr_reader name: TypeName
@@ -108,7 +124,7 @@ module RBS
 
       def initialize: (type_name: TypeName, params: Array[Symbol], ancestors: Array[Ancestor::t]) -> void
 
-      def apply: (Array[Types::t], location: Location[untyped, untyped]?) -> Array[Ancestor::t]
+      def apply: (Array[Types::t], env: Environment, location: Location[untyped, untyped]?) -> Array[Ancestor::t]
     end
 
     class SingletonAncestors
@@ -119,7 +135,7 @@ module RBS
     end
 
     type self_type = Types::ClassSingleton | Types::ClassInstance | Types::Interface
-    type definition_entry = Environment::ModuleEntry | Environment::ClassEntry | Environment::SingleEntry[TypeName, AST::Declarations::Interface]
+    type definition_entry = Environment::ModuleEntry | Environment::ClassEntry | Environment::InterfaceEntry
 
     attr_reader type_name: TypeName
     attr_reader entry: definition_entry

data/sig/definition_builder.rbs

@@ -1,53 +1,103 @@
 module RBS
   # DefinitionBuilder translates TypeName to Definition of the type
   #
-  # The translation goes three steps:
-  #
-  # 1. Calculate _ancestors_ of the type with AncestorBuilder
-  # 2. Calculate _partial_ definitions of each ancestor
-  # 3. Merge _partial_ definitions
-  #
-  # A _partial_ definition is a definition of one type name, in terms of it doesn't have methods of super classes nor included modules.
-  #
+  # It also provides semantic utilities that depends on Environment.
   #
   class DefinitionBuilder
     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, bool], Definition | false | nil]
+    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 a instance of given type name.
+    # 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, ?no_self_types: bool) -> Definition
+    def build_instance: (TypeName) -> Definition
 
+    # Returns a Definition of a singleton type
     def build_singleton: (TypeName) -> Definition
 
-    def validate_super_class!: (TypeName, Environment::ClassEntry) -> void
-
+    # Validates the given Namespace and its ancestor namespaces exists
+    #
+    # Raises NoTypeFoundError
+    #
     def ensure_namespace!: (Namespace, location: Location[untyped, untyped]?) -> void
 
-    def build_singleton0: (TypeName) -> Definition
+    # 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
 
-    def merge_definition: (src: Definition, dest: Definition, subst: Substitution, ?implemented_in: :keep | TypeName | nil, ?keep_super: bool) -> void
+    # 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
 
-    def merge_method: (TypeName, Hash[Symbol, Definition::Method], Symbol, Definition::Method, Substitution, ?implemented_in: :keep | TypeName | nil, ?keep_super: bool) -> void
+    # 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 merge_variable: (Hash[Symbol, Definition::Variable], Symbol, Definition::Variable, Substitution, ?keep_super: bool) -> void
+    # 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 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: (Array[AST::TypeParam], result: VarianceCalculator::Result) { (AST::TypeParam) -> void } -> void
 
@@ -57,87 +107,59 @@ module RBS
 
     def insert_variable: (TypeName, Hash[Symbol, Definition::Variable], name: Symbol, type: Types::t) -> void
 
-    # Add methods from `methods` to Definition
-    #
-    # * `methods`:
-    # * `interface_methods`: Methods of interfaces mixed into the type
-    # * `self_constraints_methods`: Methods of the self constraints methods
-    # * `super_interface_method`: `true` to have super method of existing method (`true` is the Definition is the target module)
+    # Add method definition to `methods`, which will be merged to `class_definition` after defining all methods at this *level* -- class, module, or interface
     #
-    def define_methods: (
-      Definition,
-      methods: MethodBuilder::Methods,
-      interface_methods: Hash[Symbol, Definition::Method],
-      methods_with_self: Hash[Symbol, Definition::Method]?,
-      super_interface_method: bool
-    ) -> void
-
-    # Define methods on singleton type
+    # `class_definition` is a definition of given type, but it has definitions of prior levels.
     #
-    def define_methods_singleton: (
-      Definition,
-      methods: MethodBuilder::Methods,
-      interface_methods: Hash[Symbol, Definition::Method]
+    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
 
-    # Define methods on instance type
+    # The `interface_methods` type describes the association between the interface name to its name and the *mixin* to a module
     #
-    def define_methods_instance: (
-      Definition,
-      methods: MethodBuilder::Methods,
-      interface_methods: Hash[Symbol, Definition::Method]
-    ) -> void
+    type interface_methods = Hash[
+      Definition::Ancestor::Instance,
+      [MethodBuilder::Methods, AST::Members::Include | AST::Members::Extend]
+    ]
 
-    # Define methods on module instance type
+    # Add method definitions from `module_methods` to `definition`
     #
-    # * Pass `nil` to `module_self_methods:` to build a module instance type that will be mixed in to other modules/classes
-    # * Pass methods from self-type-constraints to build a module instance type alone (to type check itself)
+    # It also processes interface mixins, with duplication detection.
+    # It doesn't process module mixins.
     #
-    def define_methods_module_instance: (
-      Definition,
-      methods: MethodBuilder::Methods,
-      interface_methods: Hash[Symbol, Definition::Method],
-      module_self_methods: Hash[Symbol, Definition::Method]?
+    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
 
-    # 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.
+    # Updates `definition` with methods and variables of `type_name` that can be a module or a class
     #
-    # Assume `type foo[T] = [T, T]`:
+    # It processes includes and prepends recursively.
     #
-    # ```
-    # expand_alias("::foo")   # => error
-    # ```
-    #
-    def expand_alias: (TypeName) -> Types::t
+    def define_instance: (Definition definition, TypeName type_name, Substitution subst) -> void
 
-    # Expand a type alias of given name with arguments of `untyped`.
-    #
-    # Assume `type foo[T] = [T, T]`:
+    # Updates `definition` with methods defined in an interface `type_name`
     #
-    # ```
-    # expand_alias1("::foo")   # => [untyped, untyped]
-    # ```
+    # It processes includes recursively
     #
-    def expand_alias1: (TypeName) -> Types::t
+    def define_interface: (Definition definition, TypeName type_name, Substitution subst) -> void
 
-    # Expand a type alias of given name with `args`.
-    #
-    # Assume `type foo[T] = [T, T]`:
+    # Returns a substitution that corresponds to type application
     #
     # ```
-    # expand_alias2("::foo", ["::Integer"])   # => [::Integer, ::Integer]
+    # tapp_subst(`::Array`, [`::Integer`]) # => Substitution.build([:Elem], [`::Integer`])
     # ```
     #
-    def expand_alias2: (TypeName, Array[Types::t] args) -> Types::t
-
-    def update: (env: Environment, ancestor_builder: AncestorBuilder, except: _Each[TypeName]) -> DefinitionBuilder
+    def tapp_subst: (TypeName, Array[Types::t]) -> Substitution
   end
 end

data/sig/diff.rbs

@@ -0,0 +1,28 @@
+module RBS
+  class Diff
+    @type_name: TypeName
+    @library_options: RBS::CLI::LibraryOptions
+    @after_path: Array[String]
+    @before_path: Array[String]
+    @detail: boolish
+
+    def initialize: (
+      type_name: TypeName,
+      library_options: RBS::CLI::LibraryOptions,
+      ?after_path: Array[String],
+      ?before_path: Array[String],
+      ?detail: boolish
+    ) -> void
+
+    def each_diff: () { (String before, String after) -> void } -> void
+
+    private def each_diff_by: (Symbol kind, Hash[::Symbol, Definition::Method] before_methods, Hash[::Symbol, Definition::Method] after_methods) { (String before, String after) -> void } -> void
+    private def build_methods: (Array[String] path) -> [ Hash[::Symbol, Definition::Method], Hash[::Symbol, Definition::Method] , Hash[Symbol, Constant]]
+    private def build_env: (Array[String] path) -> Environment
+    private def build_builder: (Environment env) -> DefinitionBuilder
+    private def definition_method_to_s: (Symbol key, Symbol kind, Definition::Method definition_method) -> String?
+    private def each_diff_methods: (Symbol kind, Hash[Symbol, Definition::Method], Hash[Symbol, Definition::Method]) { (String before, String after) -> void } -> void
+    private def each_diff_constants: (Hash[Symbol, Constant] before_constants, Hash[Symbol, Constant] after_constants) { (String before, String after) -> void } -> void
+    private def constant_to_s: (Constant?) -> String
+  end
+end

data/sig/directives.rbs

@@ -0,0 +1,61 @@
+module RBS
+  module AST
+    module Directives
+      type t = Use
+
+      class Base
+      end
+
+      # ```
+      # use Foo, Foo::Bar as FBar, Foo:Baz::*
+      # ```
+      #
+      class Use < Base
+        type clause = SingleClause | WildcardClause
+
+        class SingleClause
+          # Foo::Bar
+          # ^^^^^^^^       type_name
+          #
+          # Foo::Bar as X
+          #          ^^    keyword
+          #             ^  new_name
+          #
+          type loc = Location[:type_name, :keyword | :new_name]
+
+          attr_reader type_name: TypeName
+
+          attr_reader new_name: Symbol?
+
+          attr_reader location: loc?
+
+          def initialize: (type_name: TypeName, new_name: Symbol?, location: loc?) -> void
+        end
+
+        class WildcardClause
+          # Foo::Bar::*
+          # ^^^^^^^^^^    namespace
+          #           ^   star
+          #
+          type loc = Location[:namespace | :star, bot]
+
+          attr_reader namespace: Namespace
+
+          attr_reader location: loc?
+
+          def initialize: (namespace: Namespace, location: loc?) -> void
+        end
+
+        # use Foo
+        # ^^^       keyword
+        type loc = Location[:keyword, bot]
+
+        attr_reader clauses: Array[clause]
+
+        attr_reader location: loc?
+
+        def initialize: (clauses: Array[clause], location: loc?) -> void
+      end
+    end
+  end
+end