rbi 0.3.3 → 0.3.6

data/lib/rbi/rewriters/group_nodes.rb

@@ -91,22 +91,22 @@ module RBI
       @kind = kind
     end
 
-    class Kind < T::Enum
-      enums do
-        Mixins              = new
-        RequiredAncestors   = new
-        Helpers             = new
-        TypeMembers         = new
-        MixesInClassMethods = new
-        Sends               = new
-        Attrs               = new
-        TStructFields       = new
-        TEnums              = new
-        Inits               = new
-        Methods             = new
-        SingletonClasses    = new
-        Consts              = new
-      end
+    class Kind
+      Mixins              = new #: Kind
+      RequiredAncestors   = new #: Kind
+      Helpers             = new #: Kind
+      TypeMembers         = new #: Kind
+      MixesInClassMethods = new #: Kind
+      Sends               = new #: Kind
+      Attrs               = new #: Kind
+      TStructFields       = new #: Kind
+      TEnums              = new #: Kind
+      Inits               = new #: Kind
+      Methods             = new #: Kind
+      SingletonClasses    = new #: Kind
+      Consts              = new #: Kind
+
+      private_class_method(:new)
     end
   end
 end

data/lib/rbi/rewriters/merge_trees.rb

@@ -37,12 +37,12 @@ module RBI
     # end
     # ~~~
     class Merge
-      class Keep < ::T::Enum
-        enums do
-          NONE = new
-          LEFT = new
-          RIGHT = new
-        end
+      class Keep
+        NONE = new #: Keep
+        LEFT = new #: Keep
+        RIGHT = new #: Keep
+
+        private_class_method(:new)
       end
 
       class << self
@@ -79,11 +79,20 @@ module RBI
       end
 
       # Used for logging / error displaying purpose
-      class Conflict < T::Struct
-        const :left, Node
-        const :right, Node
-        const :left_name, String
-        const :right_name, String
+      class Conflict
+        #: Node
+        attr_reader :left, :right
+
+        #: String
+        attr_reader :left_name, :right_name
+
+        #: (left: Node, right: Node, left_name: String, right_name: String) -> void
+        def initialize(left:, right:, left_name:, right_name:)
+          @left = left
+          @right = right
+          @left_name = left_name
+          @right_name = right_name
+        end
 
         #: -> String
         def to_s

data/lib/rbi/rewriters/remove_known_definitions.rb

@@ -123,9 +123,15 @@ module RBI
         @operations << Operation.new(deleted_node: node, duplicate_of: previous)
       end
 
-      class Operation < T::Struct
-        const :deleted_node, Node
-        const :duplicate_of, Node
+      class Operation
+        #: Node
+        attr_reader :deleted_node, :duplicate_of
+
+        #: (deleted_node: Node, duplicate_of: Node) -> void
+        def initialize(deleted_node:, duplicate_of:)
+          @deleted_node = deleted_node
+          @duplicate_of = duplicate_of
+        end
 
         #: -> String
         def to_s

data/lib/rbi/rewriters/sort_nodes.rb

@@ -87,7 +87,7 @@ module RBI
         when Group::Kind::SingletonClasses    then 11
         when Group::Kind::Consts              then 12
         else
-          T.absurd(kind)
+          raise Error, "Unknown group kind: #{kind}"
         end
       end
 

data/lib/rbi/type.rb

@@ -3,12 +3,8 @@
 
 module RBI
   # The base class for all RBI types.
+  # @abstract
   class Type
-    extend T::Sig
-    extend T::Helpers
-
-    abstract!
-
     # Simple
 
     # A type that represents a simple class name like `String` or `Foo`.
@@ -35,6 +31,18 @@ module RBI
       def to_rbi
         @name
       end
+
+      # @override
+      #: -> Type
+      def normalize
+        self
+      end
+
+      # @override
+      #: -> Type
+      def simplify
+        self
+      end
     end
 
     # Literals
@@ -52,6 +60,18 @@ module RBI
       def to_rbi
         "T.anything"
       end
+
+      # @override
+      #: -> Type
+      def normalize
+        self
+      end
+
+      # @override
+      #: -> Type
+      def simplify
+        self
+      end
     end
 
     # `T.attached_class`.
@@ -67,6 +87,18 @@ module RBI
       def to_rbi
         "T.attached_class"
       end
+
+      # @override
+      #: -> Type
+      def normalize
+        self
+      end
+
+      # @override
+      #: -> Type
+      def simplify
+        self
+      end
     end
 
     # `T::Boolean`.
@@ -82,6 +114,18 @@ module RBI
       def to_rbi
         "T::Boolean"
       end
+
+      # @override
+      #: -> Type
+      def normalize
+        Type::Any.new([Type.simple("TrueClass"), Type.simple("FalseClass")])
+      end
+
+      # @override
+      #: -> Type
+      def simplify
+        self
+      end
     end
 
     # `T.noreturn`.
@@ -97,6 +141,18 @@ module RBI
       def to_rbi
         "T.noreturn"
       end
+
+      # @override
+      #: -> Type
+      def normalize
+        self
+      end
+
+      # @override
+      #: -> Type
+      def simplify
+        self
+      end
     end
 
     # `T.self_type`.
@@ -112,6 +168,18 @@ module RBI
       def to_rbi
         "T.self_type"
       end
+
+      # @override
+      #: -> Type
+      def normalize
+        self
+      end
+
+      # @override
+      #: -> Type
+      def simplify
+        self
+      end
     end
 
     # `T.untyped`.
@@ -127,6 +195,18 @@ module RBI
       def to_rbi
         "T.untyped"
       end
+
+      # @override
+      #: -> Type
+      def normalize
+        self
+      end
+
+      # @override
+      #: -> Type
+      def simplify
+        self
+      end
     end
 
     # `void`.
@@ -142,6 +222,18 @@ module RBI
       def to_rbi
         "void"
       end
+
+      # @override
+      #: -> Type
+      def normalize
+        self
+      end
+
+      # @override
+      #: -> Type
+      def simplify
+        self
+      end
     end
 
     # Composites
@@ -168,6 +260,18 @@ module RBI
       def to_rbi
         "T::Class[#{@type}]"
       end
+
+      # @override
+      #: -> Type
+      def normalize
+        self
+      end
+
+      # @override
+      #: -> Type
+      def simplify
+        self
+      end
     end
 
     # The singleton class of another type like `T.class_of(Foo)`.
@@ -200,6 +304,18 @@ module RBI
           "T.class_of(#{@type.to_rbi})"
         end
       end
+
+      # @override
+      #: -> Type
+      def normalize
+        self
+      end
+
+      # @override
+      #: -> Type
+      def simplify
+        self
+      end
     end
 
     # A type that can be `nil` like `T.nilable(String)`.
@@ -224,14 +340,30 @@ module RBI
       def to_rbi
         "T.nilable(#{@type.to_rbi})"
       end
+
+      # @override
+      #: -> Type
+      def normalize
+        Type::Any.new([Type.simple("NilClass"), @type.normalize])
+      end
+
+      # @override
+      #: -> Type
+      def simplify
+        case @type
+        when Nilable
+          @type.simplify
+        when Untyped
+          @type.simplify
+        else
+          self
+        end
+      end
     end
 
     # A type that is composed of multiple types like `T.all(String, Integer)`.
+    # @abstract
     class Composite < Type
-      extend T::Helpers
-
-      abstract!
-
       #: Array[Type]
       attr_reader :types
 
@@ -255,6 +387,39 @@ module RBI
       def to_rbi
         "T.all(#{@types.map(&:to_rbi).join(", ")})"
       end
+
+      # @override
+      #: -> Type
+      def normalize
+        flattened = @types.flat_map do |type|
+          type = type.normalize
+          case type
+          when All
+            type.types.map(&:normalize)
+          else
+            type
+          end
+        end.uniq
+
+        if flattened.size == 1
+          return flattened.first #: as !nil
+        end
+
+        All.new(flattened)
+      end
+
+      # @override
+      #: -> Type
+      def simplify
+        type = normalize
+
+        case type
+        when All
+          All.new(type.types.map(&:simplify))
+        else
+          type.simplify
+        end
+      end
     end
 
     # A type that is union of multiple types like `T.any(String, Integer)`.
@@ -269,6 +434,75 @@ module RBI
       def nilable?
         @types.any? { |type| type.nilable? || (type.is_a?(Simple) && type.name == "NilClass") }
       end
+
+      # @override
+      #: -> Type
+      def normalize
+        flattened = @types.flat_map do |type|
+          type = type.normalize
+          case type
+          when Any
+            type.types.map(&:normalize)
+          else
+            type
+          end
+        end.uniq
+
+        if flattened.size == 1
+          flattened.first #: as !nil
+        else
+          Any.new(flattened)
+        end
+      end
+
+      # @override
+      #: -> Type
+      def simplify
+        type = normalize
+        return type.simplify unless type.is_a?(Any)
+
+        types = type.types.map(&:simplify)
+        return Untyped.new if types.any? { |type| type.is_a?(Untyped) }
+
+        has_true_class = types.any? { |type| type.is_a?(Simple) && type.name == "TrueClass" }
+        has_false_class = types.any? { |type| type.is_a?(Simple) && type.name == "FalseClass" }
+
+        if has_true_class && has_false_class
+          types = types.reject { |type| type.is_a?(Simple) && (type.name == "TrueClass" || type.name == "FalseClass") }
+          types << Type.boolean
+        end
+
+        is_nilable = false #: bool
+
+        types = types.filter_map do |type|
+          case type
+          when Simple
+            if type.name == "NilClass"
+              is_nilable = true
+              nil
+            else
+              type
+            end
+          when Nilable
+            is_nilable = true
+            type.type
+          else
+            type
+          end
+        end.uniq
+
+        final_type = if types.size == 1
+          types.first #: as !nil
+        else
+          Any.new(types)
+        end
+
+        if is_nilable
+          return Nilable.new(final_type)
+        end
+
+        final_type
+      end
     end
 
     # Generics
@@ -299,6 +533,18 @@ module RBI
       def to_rbi
         "#{@name}[#{@params.map(&:to_rbi).join(", ")}]"
       end
+
+      # @override
+      #: -> Type
+      def normalize
+        self
+      end
+
+      # @override
+      #: -> Type
+      def simplify
+        self
+      end
     end
 
     # A type parameter like `T.type_parameter(:U)`.
@@ -323,6 +569,18 @@ module RBI
       def to_rbi
         "T.type_parameter(#{@name.inspect})"
       end
+
+      # @override
+      #: -> Type
+      def normalize
+        self
+      end
+
+      # @override
+      #: -> Type
+      def simplify
+        self
+      end
     end
 
     # Tuples and shapes
@@ -349,6 +607,18 @@ module RBI
       def to_rbi
         "[#{@types.map(&:to_rbi).join(", ")}]"
       end
+
+      # @override
+      #: -> Type
+      def normalize
+        self
+      end
+
+      # @override
+      #: -> Type
+      def simplify
+        self
+      end
     end
 
     # A shape type like `{name: String, age: Integer}`.
@@ -377,6 +647,18 @@ module RBI
           "{ " + @types.map { |name, type| "#{name}: #{type.to_rbi}" }.join(", ") + " }"
         end
       end
+
+      # @override
+      #: -> Type
+      def normalize
+        self
+      end
+
+      # @override
+      #: -> Type
+      def simplify
+        self
+      end
     end
 
     # Proc
@@ -459,6 +741,18 @@ module RBI
 
         rbi
       end
+
+      # @override
+      #: -> Type
+      def normalize
+        self
+      end
+
+      # @override
+      #: -> Type
+      def simplify
+        self
+      end
     end
 
     # Type builder
@@ -541,14 +835,8 @@ module RBI
       # it may return something other than a `RBI::Type::Nilable`.
       #: (Type type) -> Type
       def nilable(type)
-        # TODO: should we move this logic to a `flatten!`, `normalize!` or `simplify!` method?
-        return type if type.is_a?(Untyped)
-
-        if type.nilable?
-          type
-        else
-          Nilable.new(type)
-        end
+        nilable = Nilable.new(type)
+        nilable.simplify
       end
 
       # Builds a type that represents an intersection of multiple types like `T.all(String, Integer)`.
@@ -557,25 +845,7 @@ module RBI
       # it may return something other than a `All`.
       #: (Type type1, Type type2, *Type types) -> Type
       def all(type1, type2, *types)
-        types = [type1, type2, *types]
-
-        # TODO: should we move this logic to a `flatten!`, `normalize!` or `simplify!` method?
-        flattened = types.flatten.flat_map do |type|
-          case type
-          when All
-            type.types
-          else
-            type
-          end
-        end.uniq
-
-        if flattened.size == 1
-          flattened.first #: as !nil
-        else
-          raise ArgumentError, "RBI::Type.all should have at least 2 types supplied" if flattened.size < 2
-
-          All.new(flattened)
-        end
+        All.new([type1, type2, *types]).simplify
       end
 
       # Builds a type that represents a union of multiple types like `T.any(String, Integer)`.
@@ -584,64 +854,7 @@ module RBI
       # it may return something other than a `Any`.
       #: (Type type1, Type type2, *Type types) -> Type
       def any(type1, type2, *types)
-        types = [type1, type2, *types]
-
-        # TODO: should we move this logic to a `flatten!`, `normalize!` or `simplify!` method?
-        flattened = types.flatten.flat_map do |type|
-          case type
-          when Any
-            type.types
-          else
-            type
-          end
-        end
-
-        is_nilable = false #: bool
-
-        types = flattened.filter_map do |type|
-          case type
-          when Simple
-            if type.name == "NilClass"
-              is_nilable = true
-              nil
-            else
-              type
-            end
-          when Nilable
-            is_nilable = true
-            type.type
-          else
-            type
-          end
-        end.uniq
-
-        has_true_class = types.any? { |type| type.is_a?(Simple) && type.name == "TrueClass" }
-        has_false_class = types.any? { |type| type.is_a?(Simple) && type.name == "FalseClass" }
-
-        if has_true_class && has_false_class
-          types = types.reject { |type| type.is_a?(Simple) && (type.name == "TrueClass" || type.name == "FalseClass") }
-          types << boolean
-        end
-
-        type = case types.size
-        when 0
-          if is_nilable
-            is_nilable = false
-            simple("NilClass")
-          else
-            raise ArgumentError, "RBI::Type.any should have at least 2 types supplied"
-          end
-        when 1
-          types.first #: as !nil
-        else
-          Any.new(types)
-        end
-
-        if is_nilable
-          nilable(type)
-        else
-          type
-        end
+        Any.new([type1, type2, *types]).simplify
       end
 
       # Generics
@@ -649,7 +862,7 @@ module RBI
       # Builds a type that represents a generic type like `T::Array[String]` or `T::Hash[Symbol, Integer]`.
       #: (String name, *(Type | Array[Type]) params) -> Generic
       def generic(name, *params)
-        T.unsafe(Generic).new(name, *params.flatten)
+        Generic.new(name, *params.flatten)
       end
 
       # Builds a type that represents a type parameter like `T.type_parameter(:U)`.
@@ -680,9 +893,6 @@ module RBI
         Proc.new
       end
 
-      # We mark the constructor as `protected` because we want to force the use of factories on `Type` to create types
-      protected :new
-
       private
 
       #: (String name) -> bool
@@ -737,7 +947,32 @@ module RBI
       is_a?(Nilable)
     end
 
-    sig { abstract.params(other: BasicObject).returns(T::Boolean) }
+    # Returns a normalized version of the type.
+    #
+    # Normalized types are meant to be easier to process, not to read.
+    # For example, `T.any(TrueClass, FalseClass)` instead of `T::Boolean` or
+    # `T.any(String, NilClass)` instead of `T.nilable(String)`.
+    #
+    # This is the inverse of `#simplify`.
+    #
+    # @abstract
+    #: -> Type
+    def normalize; end
+
+    # Returns a simplified version of the type.
+    #
+    # Simplified types are meant to be easier to read, not to process.
+    # For example, `T::Boolean` instead of `T.any(TrueClass, FalseClass)` or
+    # `T.nilable(String)` instead of `T.any(String, NilClass)`.
+    #
+    # This is the inverse of `#normalize`.
+    #
+    # @abstract
+    #: -> Type
+    def simplify; end
+
+    # @abstract
+    #: (BasicObject) -> bool
     def ==(other); end
 
     #: (BasicObject other) -> bool
@@ -751,7 +986,8 @@ module RBI
       to_rbi.hash
     end
 
-    sig { abstract.returns(String) }
+    # @abstract
+    #: -> String
     def to_rbi; end
 
     # @override