steep 0.1.0.pre2 → 0.1.0

data/lib/steep/type_inference/block_params.rb

@@ -0,0 +1,100 @@
+module Steep
+  module TypeInference
+    class BlockParams
+      class Param
+        attr_reader :var
+        attr_reader :type
+        attr_reader :value
+        attr_reader :node
+
+        def initialize(var:, type:, value:, node:)
+          @var = var
+          @type = type
+          @value = value
+          @node = node
+        end
+
+        def ==(other)
+          other.is_a?(Param) && other.var == var && other.type == type && other.value == value && other.node == node
+        end
+
+        alias eql? ==
+
+        def hash
+          self.class.hash ^ var.hash ^ type.hash ^ value.hash ^ node.hash
+        end
+      end
+
+      attr_reader :params
+      attr_reader :rest
+
+      def initialize(params:, rest:)
+        @params = params
+        @rest = rest
+      end
+
+      def self.from_node(node, annotations:)
+        params = []
+        rest = nil
+
+        node.children.each do |arg|
+          var = arg.children.first
+          type = annotations.lookup_var_type(var.name)
+
+          case arg.type
+          when :arg, :procarg0
+            params << Param.new(var: var, type: type, value: nil, node: arg)
+          when :optarg
+            params << Param.new(var: var, type: type, value: arg.children.last, node: arg)
+          when :restarg
+            rest = Param.new(var: var, type: type, value: nil, node: arg)
+          end
+        end
+
+        new(
+          params: params,
+          rest: rest
+        )
+      end
+
+      def zip(params_type)
+        [].tap do |zip|
+          types = params_type.flat_unnamed_params
+          params.each do |param|
+            type = types.shift&.last || params_type.rest || AST::Types::Any.new
+
+            if type
+              zip << [param, type]
+            end
+          end
+
+          if rest
+            if types.empty?
+              array = AST::Types::Name.new_instance(
+                name: :Array,
+                args: [params_type.rest || AST::Types::Any.new]
+              )
+              zip << [rest, array]
+            else
+              union = AST::Types::Union.build(types: types.map(&:last) + [params_type.rest])
+              array = AST::Types::Name.new_instance(
+                name: :Array,
+                args: [union]
+              )
+              zip << [rest, array]
+            end
+          end
+        end
+      end
+
+      def each(&block)
+        if block_given?
+          params.each &block
+          yield rest if rest
+        else
+          enum_for :each
+        end
+      end
+    end
+  end
+end

data/lib/steep/type_inference/constant_env.rb

@@ -0,0 +1,55 @@
+module Steep
+  module TypeInference
+    class ConstantEnv
+      attr_reader :builder
+      attr_reader :current_namespace
+      attr_reader :cache
+
+      def initialize(builder:, current_namespace:)
+        @cache = {}
+        @builder = builder
+        @current_namespace = current_namespace
+      end
+
+      def signatures
+        builder.signatures
+      end
+
+      def lookup(name)
+        unless cache.key?(name)
+          cache[name] = lookup0(name, namespace: current_namespace)
+        end
+
+        cache[name]
+      end
+
+      def lookup0(name, namespace:)
+        if name.absolute?
+          case
+          when signatures.module_name?(name)
+            AST::Types::Name.new_module(name: name)
+          when signatures.class_name?(name)
+            AST::Types::Name.new_class(name: name, constructor: true)
+          when signatures.const_name?(name)
+            builder.absolute_type(signatures.find_const(name).type, current: nil)
+          end
+        else
+          if namespace
+            case
+            when signatures.module_name?(name, current_module: namespace)
+              AST::Types::Name.new_module(name: namespace + name)
+            when signatures.class_name?(name, current_module: namespace)
+              AST::Types::Name.new_class(name: namespace + name, constructor: true)
+            when signatures.const_name?(name, current_module: namespace)
+              builder.absolute_type(signatures.find_const(name, current_module: namespace).type, current: nil)
+            else
+              lookup0(name, namespace: namespace.parent)
+            end
+          else
+            lookup0(name.absolute!, namespace: nil)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/steep/type_inference/send_args.rb

@@ -0,0 +1,222 @@
+module Steep
+  module TypeInference
+    class SendArgs
+      attr_reader :args
+      attr_reader :kw_args
+
+      def initialize(args:, kw_args:)
+        @args = args
+        @kw_args = kw_args
+      end
+
+      def self.from_nodes(nodes)
+        args = []
+        last_hash = nil
+
+        nodes.each do |node|
+          if last_hash
+            args << last_hash
+            last_hash = nil
+          end
+
+          case node.type
+          when :hash
+            last_hash = node
+          else
+            args << node
+          end
+        end
+
+        if last_hash
+          unless kw_args?(last_hash)
+            args << last_hash
+            last_hash = nil
+          end
+        end
+
+        new(args: args, kw_args: last_hash)
+      end
+
+      def self.kw_args?(node)
+        node.children.all? do |child|
+          case child.type
+          when :pair
+            child.children[0].type == :sym
+          when :kwsplat
+            true
+          end
+        end
+      end
+
+      def each_keyword_arg
+        if block_given?
+          if kw_args
+            kw_args.children.each do |node|
+              if node.type == :pair
+                yield node
+              end
+            end
+          end
+        else
+          enum_for :each_keyword_arg
+        end
+      end
+
+      def kwsplat_nodes
+        if kw_args
+          kw_args.children.select do |node|
+            node.type == :kwsplat
+          end
+        else
+          []
+        end
+      end
+
+      def zip(params)
+        Set.new(
+          [].tap do |pairs|
+            consumed_keywords = Set.new
+            rest_types = []
+
+            params.required_keywords.each do |name, type|
+              if (node = each_keyword_arg.find {|pair| pair.children[0].children[0] == name })
+                pairs << [node.children[1], type]
+                consumed_keywords << name
+              else
+                if kwsplat_nodes.any?
+                  rest_types << type
+                else
+                  return
+                end
+              end
+            end
+
+            params.optional_keywords.each do |name, type|
+              if (node = each_keyword_arg.find {|pair| pair.children[0].children[0] == name })
+                pairs << [node.children[1], type]
+                consumed_keywords << name
+              else
+                if kwsplat_nodes.any?
+                  rest_types << type
+                end
+              end
+            end
+
+            if params.rest_keywords
+              each_keyword_arg do |pair|
+                name = pair.children[0].children[0]
+                node = pair.children[1]
+
+                unless consumed_keywords.include?(name)
+                  pairs << [node, params.rest_keywords]
+                end
+              end
+
+              if kwsplat_nodes.any?
+                pairs << [kw_args,
+                          AST::Types::Name.new_instance(
+                            name: "::Hash",
+                            args: [
+                              AST::Types::Name.new_instance(name: "::Symbol"),
+                              AST::Types::Union.build(types: rest_types + [params.rest_keywords])
+                            ]
+                          )]
+              end
+            end
+
+            if params.has_keyword?
+              if !params.rest_keywords
+                if kwsplat_nodes.empty?
+                  if each_keyword_arg.any? {|pair| !consumed_keywords.include?(pair.children[0].children[0]) }
+                    return
+                  end
+                end
+              end
+            end
+
+            args = self.args.dup
+            unless params.has_keyword?
+              args << kw_args if kw_args
+            end
+
+            arg_types = {}
+
+            params.required.each do |param|
+              if args.any?
+                next_arg(args) do |arg|
+                  save_arg_type(arg, param, arg_types)
+                end
+                consume_arg(args)
+              else
+                return
+              end
+            end
+
+            params.optional.each do |param|
+              next_arg(args) do |arg|
+                save_arg_type(arg, param, arg_types)
+              end
+              consume_arg(args)
+            end
+
+            if args.any?
+              if params.rest
+                args.each do |arg|
+                  save_arg_type(arg, params.rest, arg_types)
+                end
+              else
+                if args.none? {|arg| arg.type == :splat }
+                  return
+                end
+              end
+            end
+
+            (self.args + [kw_args].compact).each do |arg|
+              types = arg_types[arg.object_id]
+
+              if types
+                if arg.type == :splat
+                  type = AST::Types::Name.new_instance(name: "::Array", args: [AST::Types::Union.build(types: types)])
+                else
+                  type = AST::Types::Union.build(types: types)
+                end
+                pairs << [arg, type]
+              end
+            end
+          end
+        )
+      end
+
+      def save_arg_type(arg, type, hash)
+        if hash.key?(arg.object_id)
+          types = hash[arg.object_id]
+        else
+          types = hash[arg.object_id] = []
+        end
+
+        types << type
+      end
+
+      def next_arg(args)
+        if args.any?
+          case args[0].type
+          when :splat
+            args.each do |arg|
+              yield arg
+            end
+          else
+            yield args[0]
+          end
+        end
+      end
+
+      def consume_arg(args)
+        if args.any?
+          unless args[0].type == :splat
+            args.shift
+          end
+        end
+      end
+    end
+  end
+end

data/lib/steep/type_inference/type_env.rb

@@ -0,0 +1,226 @@
+module Steep
+  module TypeInference
+    class TypeEnv
+      attr_reader :subtyping
+      attr_reader :lvar_types
+      attr_reader :const_types
+      attr_reader :gvar_types
+      attr_reader :ivar_types
+      attr_reader :const_env
+
+      def initialize(subtyping:, const_env:)
+        @subtyping = subtyping
+        @lvar_types = {}
+        @const_types = {}
+        @gvar_types = {}
+        @ivar_types = {}
+        @const_env = const_env
+      end
+
+      def initialize_copy(other)
+        @subtyping = other.subtyping
+        @lvar_types = other.lvar_types.dup
+        @const_types = other.const_types.dup
+        @gvar_types = other.gvar_types.dup
+        @ivar_types = other.ivar_types.dup
+        @const_env = other.const_env
+      end
+
+      def self.build(annotations:, signatures:, subtyping:, const_env:)
+        new(subtyping: subtyping, const_env: const_env).tap do |env|
+          annotations.var_types.each do |name, annot|
+            env.set(lvar: name, type: subtyping.builder.absolute_type(annot.type, current: const_env.current_namespace))
+          end
+          annotations.ivar_types.each do |name, type|
+            env.set(ivar: name, type: subtyping.builder.absolute_type(type, current: const_env.current_namespace))
+          end
+          annotations.const_types.each do |name, type|
+            env.set(const: name, type: subtyping.builder.absolute_type(type, current: const_env.current_namespace))
+          end
+          signatures.globals.each do |name, annot|
+            type = subtyping.builder.absolute_type(annot.type, current: nil)
+            env.set(gvar: name, type: type)
+          end
+        end
+      end
+
+      def with_annotations(lvar_types: {}, ivar_types: {}, const_types: {}, gvar_types: {}, &block)
+        dup.tap do |env|
+          merge!(original_env: env.lvar_types, override_env: lvar_types, &block)
+          merge!(original_env: env.ivar_types, override_env: ivar_types, &block)
+          merge!(original_env: env.gvar_types, override_env: gvar_types, &block)
+
+          const_types.each do |name, annotated_type|
+            original_type = self.const_types[name] || const_env.lookup(name)
+            if original_type
+              assert_annotation name, original_type: original_type, annotated_type: annotated_type, &block
+            end
+            env.const_types[name] = annotated_type
+          end
+        end
+      end
+
+      def join!(envs)
+        lvars = {}
+
+        common_vars = envs.map {|env| Set.new(env.lvar_types.keys) }.inject {|a, b| a & b }
+
+        envs.each do |env|
+          env.lvar_types.each do |name, type|
+            unless lvar_types.key?(name)
+              lvars[name] = [] unless lvars[name]
+              lvars[name] << type
+            end
+          end
+        end
+
+        lvars.each do |name, types|
+          if lvar_types.key?(name) || common_vars.member?(name)
+            set(lvar: name, type: AST::Types::Union.build(types: types))
+          else
+            set(lvar: name, type: AST::Types::Union.build(types: types + [AST::Types::Name.new_instance(name: "::NilClass")]))
+          end
+        end
+      end
+
+      # @type method assert: (const: ModuleName) { () -> void } -> AST::Type
+      #                    | (gvar: Symbol) { () -> void } -> AST::Type
+      #                    | (ivar: Symbol) { () -> void } -> AST::Type
+      #                    | (lvar: Symbol) { () -> AST::Type | nil } -> AST::Type
+      def get(lvar: nil, const: nil, gvar: nil, ivar: nil)
+        case
+        when lvar
+          lvar_name(lvar).yield_self do |name|
+            if lvar_types.key?(name)
+              lvar_types[name]
+            else
+              ty = yield
+              lvar_types[name] = ty || AST::Types::Any.new
+            end
+          end
+        when const
+          if const_types.key?(const)
+            const_types[const]
+          else
+            const_env.lookup(const).yield_self do |type|
+              if type
+                type
+              else
+                yield
+                AST::Types::Any.new
+              end
+            end
+          end
+        else
+          lookup_dictionary(ivar: ivar, gvar: gvar) do |var_name, dictionary|
+            if dictionary.key?(var_name)
+              dictionary[var_name]
+            else
+              yield
+              AST::Types::Any.new
+            end
+          end
+        end
+      end
+
+      def set(lvar: nil, const: nil, gvar: nil, ivar: nil, type:)
+        case
+        when lvar
+          lvar_name(lvar).yield_self do |name|
+            lvar_types[name] = type
+          end
+        when const
+          const_types[const] = type
+        else
+          lookup_dictionary(ivar: ivar, gvar: gvar) do |var_name, dictionary|
+            dictionary[var_name] = type
+          end
+        end
+      end
+
+      # @type method assign: (const: ModuleName, type: AST::Type) { (Subtyping::Result::Failure | nil) -> void } -> AST::Type
+      #                    | (gvar: Symbol, type: AST::Type) { (Subtyping::Result::Failure | nil) -> void } -> AST::Type
+      #                    | (ivar: Symbol, type: AST::Type) { (Subtyping::Result::Failure | nil) -> void } -> AST::Type
+      #                    | (lvar: Symbol | LabeledName, type: AST::Type) { (Subtyping::Result::Failure) -> void } -> AST::Type
+      def assign(lvar: nil, const: nil, gvar: nil, ivar: nil, type:, &block)
+        case
+        when lvar
+          yield_self do
+            name = lvar_name(lvar)
+            var_type = lvar_types[name]
+            if var_type
+              assert_assign(var_type: var_type, lhs_type: type, &block)
+            else
+              lvar_types[name] = type
+            end
+          end
+        when const
+          yield_self do
+            const_type = const_types[const] || const_env.lookup(const)
+            if const_type
+              assert_assign(var_type: const_type, lhs_type: type, &block)
+            else
+              yield nil
+              AST::Types::Any.new
+            end
+          end
+        else
+          lookup_dictionary(ivar: ivar, gvar: gvar) do |var_name, dictionary|
+            if dictionary.key?(var_name)
+              assert_assign(var_type: dictionary[var_name], lhs_type: type, &block)
+            else
+              yield nil
+              AST::Types::Any.new
+            end
+          end
+        end
+      end
+
+      def lookup_dictionary(ivar:, gvar:)
+        case
+        when ivar
+          yield ivar, ivar_types
+        when gvar
+          yield gvar, gvar_types
+        end
+      end
+
+      def lvar_name(lvar)
+        case lvar
+        when Symbol
+          lvar
+        when ASTUtils::Labeling::LabeledName
+          lvar.name
+        end
+      end
+
+      def assert_assign(var_type:, lhs_type:)
+        relation = Subtyping::Relation.new(sub_type: lhs_type, super_type: var_type)
+        constraints = Subtyping::Constraints.new(unknowns: Set.new)
+
+        subtyping.check(relation, constraints: constraints).else do |result|
+          yield result
+        end
+
+        var_type
+      end
+
+      def merge!(original_env:, override_env:, &block)
+        original_env.merge!(override_env) do |name, original_type, override_type|
+          assert_annotation name, annotated_type: override_type, original_type: original_type, &block
+        end
+      end
+
+      def assert_annotation(name, annotated_type:, original_type:)
+        relation = Subtyping::Relation.new(sub_type: annotated_type, super_type: original_type)
+        constraints = Subtyping::Constraints.new(unknowns: Set.new)
+
+        subtyping.check(relation, constraints: constraints).else do |result|
+          yield name, relation, result
+        end
+
+        annotated_type
+      end
+    end
+  end
+end

data/lib/steep/type_name.rb

@@ -12,21 +12,27 @@ module Steep
       end
 
       def hash
-        name.hash
+        self.class.hash ^ name.hash
       end
 
-      def eql?(other)
-        self == other
-      end
+      alias eql? ==
 
       def to_s
         name.to_s
       end
+
+      def map_module_name
+        self.class.new(name: yield(name))
+      end
     end
 
-    class Interface < Base; end
+    class Interface < Base
+      def map_module_name
+        self
+      end
+    end
 
-    class Module < Base
+    class Class < Base
       attr_reader :constructor
 
       def to_s
@@ -39,7 +45,7 @@ module Steep
               " noconstructor"
             end
 
-        "#{name}.module#{k}"
+        "#{name}.class#{k}"
       end
 
       def initialize(name:, constructor:)
@@ -51,6 +57,10 @@ module Steep
         other.is_a?(self.class) && other.name == name && other.constructor == constructor
       end
 
+      def hash
+        self.class.hash ^ name.hash ^ constructor.hash
+      end
+
       NOTHING = Object.new
 
       def updated(constructor: NOTHING)
@@ -60,6 +70,16 @@ module Steep
 
         self.class.new(name: name, constructor: constructor)
       end
+
+      def map_module_name
+        self.class.new(name: yield(name), constructor: constructor)
+      end
+    end
+
+    class Module < Base
+      def to_s
+        "#{name}.module"
+      end
     end
 
     class Instance < Base; end

data/lib/steep/typing.rb

@@ -23,6 +23,10 @@ module Steep
       type
     end
 
+    def has_type?(node)
+      typing.key?(node.__id__)
+    end
+
     def add_var_type(variable, type)
       if var_typing.key?(variable)
         unless var_typing[variable] == type

data/lib/steep/version.rb

@@ -1,3 +1,3 @@
 module Steep
-  VERSION = "0.1.0.pre2"
+  VERSION = "0.1.0"
 end