steep 0.23.0 → 0.29.0

data/lib/steep/drivers/check.rb

@@ -60,6 +60,10 @@ module Steep
                   Steep.log_error source_file.status.error
                 end
               end
+            when Project::Target::SignatureOtherErrorStatus
+              Steep.log_error status.error
+            else
+              Steep.logger.error { "Unexpected status: #{status.class}" }
             end
           end
         end

data/lib/steep/errors.rb

@@ -543,5 +543,19 @@ module Steep
         "#{location_to_str}: MissingKeyword: #{missing_keywords.to_a.join(", ")}"
       end
     end
+
+    class UnsupportedSyntax < Base
+      attr_reader :message
+
+      def initialize(node:, message: nil)
+        super(node: node)
+        @message = message
+      end
+
+      def to_s
+        msg = message || "#{node.type} is not supported"
+        "#{location_to_str}: UnsupportedSyntax: #{msg}"
+      end
+    end
   end
 end

data/lib/steep/interface/interface.rb

@@ -1,72 +1,15 @@
 module Steep
   module Interface
     class Interface
-      class Combination
-        attr_reader :operator
-        attr_reader :types
+      class Entry
+        attr_reader :method_types
 
-        def initialize(operator:, types:)
-          @types = types
-          @operator = operator
-          @incompatible = false
-        end
-
-        def overload?
-          operator == :overload
-        end
-
-        def union?
-          operator == :union
-        end
-
-        def intersection?
-          operator == :intersection
-        end
-
-        def self.overload(types, incompatible:)
-          new(operator: :overload, types: types).incompatible!(incompatible)
-        end
-
-        def incompatible?
-          @incompatible
-        end
-
-        def incompatible!(value)
-          @incompatible = value
-          self
-        end
-
-        def self.union(types)
-          case types.size
-          when 0
-            raise "Combination.union called with zero types"
-          when 1
-            types.first
-          else
-            new(operator: :union, types: types)
-          end
-        end
-
-        def self.intersection(types)
-          case types.size
-          when 0
-            raise "Combination.intersection called with zero types"
-          when 1
-            types.first
-          else
-            new(operator: :intersection, types: types)
-          end
+        def initialize(method_types:)
+          @method_types = method_types
         end
 
         def to_s
-          case operator
-          when :overload
-            "{ #{types.map(&:to_s).join(" | ")} }"
-          when :union
-            "[#{types.map(&:to_s).join(" | ")}]"
-          when :intersection
-            "[#{types.map(&:to_s).join(" & ")}]"
-          end
+          "{ #{method_types.join(" || ")} }"
         end
       end
 

data/lib/steep/interface/method_type.rb

@@ -17,15 +17,14 @@ module Steep
         @rest_keywords = rest_keywords
       end
 
-      NONE = Object.new
-      def update(required: NONE, optional: NONE, rest: NONE, required_keywords: NONE, optional_keywords: NONE, rest_keywords: NONE)
+      def update(required: self.required, optional: self.optional, rest: self.rest, required_keywords: self.required_keywords, optional_keywords: self.optional_keywords, rest_keywords: self.rest_keywords)
         self.class.new(
-          required: required.equal?(NONE) ? self.required : required,
-          optional: optional.equal?(NONE) ? self.optional : optional,
-          rest: rest.equal?(NONE) ? self.rest : rest,
-          required_keywords: required_keywords.equal?(NONE) ? self.required_keywords : required_keywords,
-          optional_keywords: optional_keywords.equal?(NONE) ? self.optional_keywords : optional_keywords,
-          rest_keywords: rest_keywords.equal?(NONE) ? self.rest_keywords : rest_keywords
+          required: required,
+          optional: optional,
+          rest: rest,
+          required_keywords: required_keywords,
+          optional_keywords: optional_keywords,
+          rest_keywords: rest_keywords,
         )
       end
 
@@ -84,6 +83,12 @@ module Steep
           other.rest_keywords == rest_keywords
       end
 
+      alias eql? ==
+
+      def hash
+        required.hash ^ optional.hash ^ rest.hash ^ required_keywords.hash ^ optional_keywords.hash ^ rest_keywords.hash
+      end
+
       def flat_unnamed_params
         required.map {|p| [:required, p] } + optional.map {|p| [:optional, p] }
       end
@@ -211,10 +216,10 @@ module Steep
         end
       end
 
-      def free_variables
-        Set.new.tap do |fvs|
+      def free_variables()
+        @fvs ||= Set.new.tap do |set|
           each_type do |type|
-            fvs.merge type.free_variables
+            set.merge(type.free_variables)
           end
         end
       end
@@ -224,14 +229,29 @@ module Steep
       end
 
       def subst(s)
-        self.class.new(
-          required: required.map {|t| t.subst(s) },
-          optional: optional.map {|t| t.subst(s) },
-          rest: rest&.subst(s),
-          required_keywords: required_keywords.transform_values {|t| t.subst(s) },
-          optional_keywords: optional_keywords.transform_values {|t| t.subst(s) },
-          rest_keywords: rest_keywords&.subst(s)
-        )
+        return self if s.empty?
+        return self if empty?
+        return self if free_variables.disjoint?(s.domain)
+
+        rs = required.map {|t| t.subst(s) }
+        os = optional.map {|t| t.subst(s) }
+        r = rest&.subst(s)
+        rk = required_keywords.transform_values {|t| t.subst(s) }
+        ok = optional_keywords.transform_values {|t| t.subst(s) }
+        k = rest_keywords&.subst(s)
+
+        if rs == required && os == optional && r == rest && rk == required_keywords && ok == optional_keywords && k == rest_keywords
+          self
+        else
+          self.class.new(
+            required: required.map {|t| t.subst(s) },
+            optional: optional.map {|t| t.subst(s) },
+            rest: rest&.subst(s),
+            required_keywords: required_keywords.transform_values {|t| t.subst(s) },
+            optional_keywords: optional_keywords.transform_values {|t| t.subst(s) },
+            rest_keywords: rest_keywords&.subst(s)
+          )
+        end
       end
 
       def size
@@ -263,59 +283,61 @@ module Steep
         !has_positional? && !has_keywords?
       end
 
-      def |(other)
+      # self + params returns a new params for overloading.
+      #
+      def +(other)
         a = first_param
         b = other.first_param
 
         case
         when a.is_a?(RequiredPositional) && b.is_a?(RequiredPositional)
           AST::Types::Union.build(types: [a.type, b.type]).yield_self do |type|
-            (self.drop_first | other.drop_first).with_first_param(RequiredPositional.new(type))
+            (self.drop_first + other.drop_first).with_first_param(RequiredPositional.new(type))
           end
         when a.is_a?(RequiredPositional) && b.is_a?(OptionalPositional)
           AST::Types::Union.build(types: [a.type, b.type]).yield_self do |type|
-            (self.drop_first | other.drop_first).with_first_param(OptionalPositional.new(type))
+            (self.drop_first + other.drop_first).with_first_param(OptionalPositional.new(type))
           end
         when a.is_a?(RequiredPositional) && b.is_a?(RestPositional)
           AST::Types::Union.build(types: [a.type, b.type]).yield_self do |type|
-            (self.drop_first | other).with_first_param(OptionalPositional.new(type))
+            (self.drop_first + other).with_first_param(OptionalPositional.new(type))
           end
         when a.is_a?(RequiredPositional) && b.nil?
-          (self.drop_first | other).with_first_param(OptionalPositional.new(a.type))
+          (self.drop_first + other).with_first_param(OptionalPositional.new(a.type))
         when a.is_a?(OptionalPositional) && b.is_a?(RequiredPositional)
           AST::Types::Union.build(types: [a.type, b.type]).yield_self do |type|
-            (self.drop_first | other.drop_first).with_first_param(OptionalPositional.new(type))
+            (self.drop_first + other.drop_first).with_first_param(OptionalPositional.new(type))
           end
         when a.is_a?(OptionalPositional) && b.is_a?(OptionalPositional)
           AST::Types::Union.build(types: [a.type, b.type]).yield_self do |type|
-            (self.drop_first | other.drop_first).with_first_param(OptionalPositional.new(type))
+            (self.drop_first + other.drop_first).with_first_param(OptionalPositional.new(type))
           end
         when a.is_a?(OptionalPositional) && b.is_a?(RestPositional)
           AST::Types::Union.build(types: [a.type, b.type]).yield_self do |type|
-            (self.drop_first | other).with_first_param(OptionalPositional.new(type))
+            (self.drop_first + other).with_first_param(OptionalPositional.new(type))
           end
         when a.is_a?(OptionalPositional) && b.nil?
-          (self.drop_first | other).with_first_param(OptionalPositional.new(a.type))
+          (self.drop_first + other).with_first_param(OptionalPositional.new(a.type))
         when a.is_a?(RestPositional) && b.is_a?(RequiredPositional)
           AST::Types::Union.build(types: [a.type, b.type]).yield_self do |type|
-            (self | other.drop_first).with_first_param(OptionalPositional.new(type))
+            (self + other.drop_first).with_first_param(OptionalPositional.new(type))
           end
         when a.is_a?(RestPositional) && b.is_a?(OptionalPositional)
           AST::Types::Union.build(types: [a.type, b.type]).yield_self do |type|
-            (self | other.drop_first).with_first_param(OptionalPositional.new(type))
+            (self + other.drop_first).with_first_param(OptionalPositional.new(type))
           end
         when a.is_a?(RestPositional) && b.is_a?(RestPositional)
           AST::Types::Union.build(types: [a.type, b.type]).yield_self do |type|
-            (self.drop_first | other.drop_first).with_first_param(RestPositional.new(type))
+            (self.drop_first + other.drop_first).with_first_param(RestPositional.new(type))
           end
         when a.is_a?(RestPositional) && b.nil?
-          (self.drop_first | other).with_first_param(RestPositional.new(a.type))
+          (self.drop_first + other).with_first_param(RestPositional.new(a.type))
         when a.nil? && b.is_a?(RequiredPositional)
-          (self | other.drop_first).with_first_param(OptionalPositional.new(b.type))
+          (self + other.drop_first).with_first_param(OptionalPositional.new(b.type))
         when a.nil? && b.is_a?(OptionalPositional)
-          (self | other.drop_first).with_first_param(OptionalPositional.new(b.type))
+          (self + other.drop_first).with_first_param(OptionalPositional.new(b.type))
         when a.nil? && b.is_a?(RestPositional)
-          (self | other.drop_first).with_first_param(RestPositional.new(b.type))
+          (self + other.drop_first).with_first_param(RestPositional.new(b.type))
         when a.nil? && b.nil?
           required_keywords = {}
 
@@ -395,6 +417,9 @@ module Steep
         end
       end
 
+      # Returns the intersection between self and other.
+      # Returns nil if the intersection cannot be computed.
+      #
       def &(other)
         a = first_param
         b = other.first_param
@@ -402,48 +427,48 @@ module Steep
         case
         when a.is_a?(RequiredPositional) && b.is_a?(RequiredPositional)
           AST::Types::Intersection.build(types: [a.type, b.type]).yield_self do |type|
-            (self.drop_first & other.drop_first).with_first_param(RequiredPositional.new(type))
+            (self.drop_first & other.drop_first)&.with_first_param(RequiredPositional.new(type))
           end
         when a.is_a?(RequiredPositional) && b.is_a?(OptionalPositional)
           AST::Types::Intersection.build(types: [a.type, b.type]).yield_self do |type|
-            (self.drop_first & other.drop_first).with_first_param(RequiredPositional.new(type))
+            (self.drop_first & other.drop_first)&.with_first_param(RequiredPositional.new(type))
           end
         when a.is_a?(RequiredPositional) && b.is_a?(RestPositional)
           AST::Types::Intersection.build(types: [a.type, b.type]).yield_self do |type|
-            (self.drop_first & other).with_first_param(RequiredPositional.new(type))
+            (self.drop_first & other)&.with_first_param(RequiredPositional.new(type))
           end
         when a.is_a?(RequiredPositional) && b.nil?
-          (self.drop_first & other).with_first_param(RequiredPositional.new(AST::Types::Bot.new))
+          nil
         when a.is_a?(OptionalPositional) && b.is_a?(RequiredPositional)
           AST::Types::Intersection.build(types: [a.type, b.type]).yield_self do |type|
-            (self.drop_first & other.drop_first).with_first_param(RequiredPositional.new(type))
+            (self.drop_first & other.drop_first)&.with_first_param(RequiredPositional.new(type))
           end
         when a.is_a?(OptionalPositional) && b.is_a?(OptionalPositional)
           AST::Types::Intersection.build(types: [a.type, b.type]).yield_self do |type|
-            (self.drop_first & other.drop_first).with_first_param(OptionalPositional.new(type))
+            (self.drop_first & other.drop_first)&.with_first_param(OptionalPositional.new(type))
           end
         when a.is_a?(OptionalPositional) && b.is_a?(RestPositional)
           AST::Types::Intersection.build(types: [a.type, b.type]).yield_self do |type|
-            (self.drop_first & other).with_first_param(OptionalPositional.new(type))
+            (self.drop_first & other)&.with_first_param(OptionalPositional.new(type))
           end
         when a.is_a?(OptionalPositional) && b.nil?
           self.drop_first & other
         when a.is_a?(RestPositional) && b.is_a?(RequiredPositional)
           AST::Types::Intersection.build(types: [a.type, b.type]).yield_self do |type|
-            (self & other.drop_first).with_first_param(RequiredPositional.new(type))
+            (self & other.drop_first)&.with_first_param(RequiredPositional.new(type))
           end
         when a.is_a?(RestPositional) && b.is_a?(OptionalPositional)
           AST::Types::Intersection.build(types: [a.type, b.type]).yield_self do |type|
-            (self & other.drop_first).with_first_param(OptionalPositional.new(type))
+            (self & other.drop_first)&.with_first_param(OptionalPositional.new(type))
           end
         when a.is_a?(RestPositional) && b.is_a?(RestPositional)
           AST::Types::Intersection.build(types: [a.type, b.type]).yield_self do |type|
-            (self.drop_first & other.drop_first).with_first_param(RestPositional.new(type))
+            (self.drop_first & other.drop_first)&.with_first_param(RestPositional.new(type))
           end
         when a.is_a?(RestPositional) && b.nil?
           self.drop_first & other
         when a.nil? && b.is_a?(RequiredPositional)
-          (self & other.drop_first).with_first_param(RequiredPositional.new(AST::Types::Bot.new))
+          nil
         when a.nil? && b.is_a?(OptionalPositional)
           self & other.drop_first
         when a.nil? && b.is_a?(RestPositional)
@@ -452,7 +477,7 @@ module Steep
           optional_keywords = {}
 
           (Set.new(self.optional_keywords.keys) & Set.new(other.optional_keywords.keys)).each do |keyword|
-            self.optional_keywords[keyword] = AST::Types::Intersection.build(
+            optional_keywords[keyword] = AST::Types::Intersection.build(
               types: [
                 self.optional_keywords[keyword],
                 other.optional_keywords[keyword]
@@ -467,9 +492,7 @@ module Steep
               when other.required_keywords.key?(keyword)
                 required_keywords[keyword] = AST::Types::Intersection.build(types: [t, other.required_keywords[keyword]])
               when other.rest_keywords
-                required_keywords[keyword] = AST::Types::Intersection.build(types: [t, other.rest_keywords])
-              else
-                required_keywords[keyword] = t
+                optional_keywords[keyword] = AST::Types::Intersection.build(types: [t, other.rest_keywords])
               end
             end
           end
@@ -479,9 +502,7 @@ module Steep
               when self.required_keywords.key?(keyword)
                 required_keywords[keyword] = AST::Types::Intersection.build(types: [t, self.required_keywords[keyword]])
               when self.rest_keywords
-                required_keywords[keyword] = AST::Types::Intersection.build(types: [t, self.rest_keywords])
-              else
-                required_keywords[keyword] = t
+                optional_keywords[keyword] = AST::Types::Intersection.build(types: [t, self.rest_keywords])
               end
             end
           end
@@ -493,7 +514,7 @@ module Steep
               when other.rest_keywords
                 required_keywords[keyword] = AST::Types::Intersection.build(types: [t, other.rest_keywords])
               else
-                required_keywords[keyword] = t
+                return
               end
             end
           end
@@ -505,7 +526,7 @@ module Steep
               when self.rest_keywords
                 required_keywords[keyword] = AST::Types::Intersection.build(types: [t, self.rest_keywords])
               else
-                required_keywords[keyword] = t
+                return
               end
             end
           end
@@ -514,7 +535,153 @@ module Steep
                  when self.rest_keywords && other.rest_keywords
                    AST::Types::Intersection.build(types: [self.rest_keywords, other.rest_keywords])
                  else
-                   self.rest_keywords || other.rest_keywords
+                   nil
+                 end
+
+          Params.new(
+            required: [],
+            optional: [],
+            rest: nil,
+            required_keywords: required_keywords,
+            optional_keywords: optional_keywords,
+            rest_keywords: rest)
+        end
+      end
+
+      # Returns the union between self and other.
+      #
+      def |(other)
+        a = first_param
+        b = other.first_param
+
+        case
+        when a.is_a?(RequiredPositional) && b.is_a?(RequiredPositional)
+          AST::Types::Union.build(types: [a.type, b.type]).yield_self do |type|
+            (self.drop_first | other.drop_first)&.with_first_param(RequiredPositional.new(type))
+          end
+        when a.is_a?(RequiredPositional) && b.is_a?(OptionalPositional)
+          AST::Types::Union.build(types: [a.type, b.type]).yield_self do |type|
+            (self.drop_first | other.drop_first)&.with_first_param(OptionalPositional.new(type))
+          end
+        when a.is_a?(RequiredPositional) && b.is_a?(RestPositional)
+          AST::Types::Union.build(types: [a.type, b.type]).yield_self do |type|
+            (self.drop_first | other.drop_first)&.with_first_param(OptionalPositional.new(type))
+          end
+        when a.is_a?(RequiredPositional) && b.nil?
+          self.drop_first&.with_first_param(OptionalPositional.new(a.type))
+        when a.is_a?(OptionalPositional) && b.is_a?(RequiredPositional)
+          AST::Types::Union.build(types: [a.type, b.type]).yield_self do |type|
+            (self.drop_first | other.drop_first)&.with_first_param(OptionalPositional.new(type))
+          end
+        when a.is_a?(OptionalPositional) && b.is_a?(OptionalPositional)
+          AST::Types::Union.build(types: [a.type, b.type]).yield_self do |type|
+            (self.drop_first | other.drop_first)&.with_first_param(OptionalPositional.new(type))
+          end
+        when a.is_a?(OptionalPositional) && b.is_a?(RestPositional)
+          AST::Types::Union.build(types: [a.type, b.type]).yield_self do |type|
+            (self.drop_first | other.drop_first)&.with_first_param(OptionalPositional.new(type))
+          end
+        when a.is_a?(OptionalPositional) && b.nil?
+          (self.drop_first | other)&.with_first_param(a)
+        when a.is_a?(RestPositional) && b.is_a?(RequiredPositional)
+          AST::Types::Union.build(types: [a.type, b.type]).yield_self do |type|
+            (self.drop_first | other.drop_first)&.with_first_param(OptionalPositional.new(type))
+          end
+        when a.is_a?(RestPositional) && b.is_a?(OptionalPositional)
+          AST::Types::Union.build(types: [a.type, b.type]).yield_self do |type|
+            (self | other.drop_first)&.with_first_param(OptionalPositional.new(type))
+          end
+        when a.is_a?(RestPositional) && b.is_a?(RestPositional)
+          AST::Types::Union.build(types: [a.type, b.type]).yield_self do |type|
+            (self.drop_first | other.drop_first)&.with_first_param(RestPositional.new(type))
+          end
+        when a.is_a?(RestPositional) && b.nil?
+          (self.drop_first | other)&.with_first_param(a)
+        when a.nil? && b.is_a?(RequiredPositional)
+          other.drop_first&.with_first_param(OptionalPositional.new(b.type))
+        when a.nil? && b.is_a?(OptionalPositional)
+          (self | other.drop_first)&.with_first_param(b)
+        when a.nil? && b.is_a?(RestPositional)
+          (self | other.drop_first)&.with_first_param(b)
+        when a.nil? && b.nil?
+          required_keywords = {}
+          optional_keywords = {}
+
+          (Set.new(self.required_keywords.keys) & Set.new(other.required_keywords.keys)).each do |keyword|
+            required_keywords[keyword] = AST::Types::Union.build(
+              types: [
+                self.required_keywords[keyword],
+                other.required_keywords[keyword]
+              ]
+            )
+          end
+
+          self.optional_keywords.each do |keyword, t|
+            unless optional_keywords.key?(keyword) || required_keywords.key?(keyword)
+              case
+              when s = other.required_keywords[keyword]
+                optional_keywords[keyword] = AST::Types::Union.build(types: [t, s])
+              when s = other.optional_keywords[keyword]
+                optional_keywords[keyword] = AST::Types::Union.build(types: [t, s])
+              when r = other.rest_keywords
+                optional_keywords[keyword] = AST::Types::Union.build(types: [t, r])
+              else
+                optional_keywords[keyword] = t
+              end
+            end
+          end
+          other.optional_keywords.each do |keyword, t|
+            unless optional_keywords.key?(keyword) || required_keywords.key?(keyword)
+              case
+              when s = self.required_keywords[keyword]
+                optional_keywords[keyword] = AST::Types::Union.build(types: [t, s])
+              when s = self.optional_keywords[keyword]
+                optional_keywords[keyword] = AST::Types::Union.build(types: [t, s])
+              when r = self.rest_keywords
+                optional_keywords[keyword] = AST::Types::Union.build(types: [t, r])
+              else
+                optional_keywords[keyword] = t
+              end
+            end
+          end
+          self.required_keywords.each do |keyword, t|
+            unless optional_keywords.key?(keyword) || required_keywords.key?(keyword)
+              case
+              when s = other.optional_keywords[keyword]
+                optional_keywords[keyword] = AST::Types::Union.build(types: [t, s])
+              when r = other.rest_keywords
+                optional_keywords[keyword] = AST::Types::Union.build(types: [t, r])
+              else
+                optional_keywords[keyword] = t
+              end
+            end
+          end
+          other.required_keywords.each do |keyword, t|
+            unless optional_keywords.key?(keyword) || required_keywords.key?(keyword)
+              case
+              when s = self.optional_keywords[keyword]
+                optional_keywords[keyword] = AST::Types::Union.build(types: [t, s])
+              when r = self.rest_keywords
+                optional_keywords[keyword] = AST::Types::Union.build(types: [t, r])
+              else
+                optional_keywords[keyword] = t
+              end
+            end
+          end
+
+          rest = case
+                 when self.rest_keywords && other.rest_keywords
+                   AST::Types::Union.build(types: [self.rest_keywords, other.rest_keywords])
+                 when self.rest_keywords
+                   if required_keywords.empty? && optional_keywords.empty?
+                     self.rest_keywords
+                   end
+                 when other.rest_keywords
+                   if required_keywords.empty? && optional_keywords.empty?
+                     other.rest_keywords
+                   end
+                 else
+                   nil
                  end
 
           Params.new(
@@ -552,19 +719,30 @@ module Steep
         other.is_a?(self.class) && other.type == type && other.optional == optional
       end
 
+      alias eql? ==
+
+      def hash
+        type.hash ^ optional.hash
+      end
+
       def closed?
         type.closed?
       end
 
       def subst(s)
-        self.class.new(
-          type: type.subst(s),
-          optional: optional
-        )
+        ty = type.subst(s)
+        if ty == type
+          self
+        else
+          self.class.new(
+            type: ty,
+            optional: optional
+          )
+        end
       end
 
-      def free_variables
-        type.free_variables
+      def free_variables()
+        @fvs ||= type.free_variables
       end
 
       def to_s
@@ -580,9 +758,10 @@ module Steep
 
       def +(other)
         optional = self.optional? || other.optional?
-        type = AST::Types::Proc.new(params: self.type.params | other.type.params,
-                                    return_type: AST::Types::Union.build(types: [self.type.return_type,
-                                                                                 other.type.return_type]))
+        type = AST::Types::Proc.new(
+          params: self.type.params + other.type.params,
+          return_type: AST::Types::Union.build(types: [self.type.return_type, other.type.return_type])
+        )
         self.class.new(
           type: type,
           optional: optional
@@ -596,15 +775,15 @@ module Steep
       attr_reader :block
       attr_reader :return_type
       attr_reader :location
+      attr_reader :method_def
 
-      NONE = Object.new
-
-      def initialize(type_params:, params:, block:, return_type:, location:)
+      def initialize(type_params:, params:, block:, return_type:, location:, method_def:)
         @type_params = type_params
         @params = params
         @block = block
         @return_type = return_type
         @location = location
+        @method_def = method_def
       end
 
       def ==(other)
@@ -613,14 +792,31 @@ module Steep
           other.params == params &&
           other.block == block &&
           other.return_type == return_type &&
+          (!other.method_def || !method_def || other.method_def == method_def) &&
           (!other.location || !location || other.location == location)
       end
 
+      alias eql? ==
+
+      def hash
+        type_params.hash ^ params.hash ^ block.hash ^ return_type.hash
+      end
+
       def free_variables
-        (params.free_variables + (block&.free_variables || Set.new) + return_type.free_variables) - Set.new(type_params)
+        @fvs ||= Set.new.tap do |set|
+          set.merge(params.free_variables)
+          if block
+            set.merge(block.free_variables)
+          end
+          set.merge(return_type.free_variables)
+          set.subtract(type_params)
+        end
       end
 
       def subst(s)
+        return self if s.empty?
+        return self if free_variables.disjoint?(s.domain)
+
         s_ = s.except(type_params)
 
         self.class.new(
@@ -628,6 +824,7 @@ module Steep
           params: params.subst(s_),
           block: block&.subst(s_),
           return_type: return_type.subst(s_),
+          method_def: method_def,
           location: location
         )
       end
@@ -646,23 +843,21 @@ module Steep
       end
 
       def instantiate(s)
-        self.class.new(
-          type_params: [],
-          params: params.subst(s),
-          block: block&.subst(s),
-          return_type: return_type.subst(s),
-          location: location,
-          )
+        self.class.new(type_params: [],
+                       params: params.subst(s),
+                       block: block&.subst(s),
+                       return_type: return_type.subst(s),
+                       location: location,
+                       method_def: method_def)
       end
 
-      def with(type_params: NONE, params: NONE, block: NONE, return_type: NONE, location: NONE)
-        self.class.new(
-          type_params: type_params.equal?(NONE) ? self.type_params : type_params,
-          params: params.equal?(NONE) ? self.params : params,
-          block: block.equal?(NONE) ? self.block : block,
-          return_type: return_type.equal?(NONE) ? self.return_type : return_type,
-          location: location.equal?(NONE) ? self.location : location
-        )
+      def with(type_params: self.type_params, params: self.params, block: self.block, return_type: self.return_type, location: self.location,  method_def: self.method_def)
+        self.class.new(type_params: type_params,
+                       params: params,
+                       block: block,
+                       return_type: return_type,
+                       method_def: method_def,
+                       location: location)
       end
 
       def to_s
@@ -674,16 +869,17 @@ module Steep
       end
 
       def map_type(&block)
-        self.class.new(
-          type_params: type_params,
-          params: params.map_type(&block),
-          block: self.block&.yield_self {|blk| blk.map_type(&block) },
-          return_type: yield(return_type),
-          location: location
-        )
+        self.class.new(type_params: type_params,
+                       params: params.map_type(&block),
+                       block: self.block&.yield_self {|blk| blk.map_type(&block) },
+                       return_type: yield(return_type),
+                       location: location,
+                       method_def: method_def)
       end
 
-      def +(other)
+      # Returns a new method type which can be used for the method implementation type of both `self` and `other`.
+      #
+      def unify_overload(other)
         type_params = []
         s1 = Substitution.build(self.type_params)
         type_params.push(*s1.dictionary.values.map(&:name))
@@ -701,11 +897,116 @@ module Steep
 
         self.class.new(
           type_params: type_params,
-          params: params.subst(s1) | other.params.subst(s2),
+          params: params.subst(s1) + other.params.subst(s2),
           block: block,
           return_type: AST::Types::Union.build(
             types: [return_type.subst(s1),other.return_type.subst(s2)]
           ),
+          method_def: method_def,
+          location: nil
+        )
+      end
+
+      def +(other)
+        unify_overload(other)
+      end
+
+      # Returns a method type which is a super-type of both self and other.
+      #   self <: (self | other) && other <: (self | other)
+      #
+      # Returns nil if self and other are incompatible.
+      #
+      def |(other)
+        self_type_params = Set.new(self.type_params)
+        other_type_params = Set.new(other.type_params)
+
+        unless (common_type_params = (self_type_params & other_type_params).to_a).empty?
+          fresh_types = common_type_params.map {|name| AST::Types::Var.fresh(name) }
+          fresh_names = fresh_types.map(&:name)
+          subst = Substitution.build(common_type_params, fresh_types)
+          other = other.instantiate(subst)
+          type_params = (self_type_params + (other_type_params - common_type_params + Set.new(fresh_names))).to_a
+        else
+          type_params = (self_type_params + other_type_params).to_a
+        end
+
+        params = self.params & other.params or return
+        block = case
+                when self.block && other.block
+                  block_params = self.block.type.params | other.block.type.params
+                  block_return_type = AST::Types::Intersection.build(types: [self.block.type.return_type, other.block.type.return_type])
+                  block_type = AST::Types::Proc.new(params: block_params,
+                                                    return_type: block_return_type,
+                                                    location: nil)
+                  Block.new(
+                    type: block_type,
+                    optional: self.block.optional && other.block.optional
+                  )
+                when self.block && self.block.optional?
+                  self.block
+                when other.block && other.block.optional?
+                  other.block
+                when !self.block && !other.block
+                  nil
+                else
+                  return
+                end
+        return_type = AST::Types::Union.build(types: [self.return_type, other.return_type])
+
+        MethodType.new(
+          params: params,
+          block: block,
+          return_type: return_type,
+          type_params: type_params,
+          method_def: nil,
+          location: nil
+        )
+      end
+
+      # Returns a method type which is a sub-type of both self and other.
+      #   (self & other) <: self && (self & other) <: other
+      #
+      # Returns nil if self and other are incompatible.
+      #
+      def &(other)
+        self_type_params = Set.new(self.type_params)
+        other_type_params = Set.new(other.type_params)
+
+        unless (common_type_params = (self_type_params & other_type_params).to_a).empty?
+          fresh_types = common_type_params.map {|name| AST::Types::Var.fresh(name) }
+          fresh_names = fresh_types.map(&:name)
+          subst = Substitution.build(common_type_params, fresh_types)
+          other = other.subst(subst)
+          type_params = (self_type_params + (other_type_params - common_type_params + Set.new(fresh_names))).to_a
+        else
+          type_params = (self_type_params + other_type_params).to_a
+        end
+
+        params = self.params | other.params
+        block = case
+                when self.block && other.block
+                  block_params = self.block.type.params & other.block.type.params or return
+                  block_return_type = AST::Types::Union.build(types: [self.block.type.return_type, other.block.type.return_type])
+                  block_type = AST::Types::Proc.new(params: block_params,
+                                                    return_type: block_return_type,
+                                                    location: nil)
+                  Block.new(
+                    type: block_type,
+                    optional: self.block.optional || other.block.optional
+                  )
+
+                else
+                  self.block || other.block
+                end
+
+        return_type = AST::Types::Intersection.build(types: [self.return_type, other.return_type])
+
+        MethodType.new(
+          params: params,
+          block: block,
+          return_type: return_type,
+          type_params: type_params,
+          method_def: nil,
           location: nil
         )
       end