steep 0.1.0.pre

data/lib/steep/cli.rb

@@ -0,0 +1,79 @@
+require 'optparse'
+
+module Steep
+  class CLI
+    attr_reader :argv
+    attr_reader :stdout
+    attr_reader :stdin
+    attr_reader :stderr
+    attr_reader :command
+
+    def initialize(stdout:, stdin:, stderr:, argv:)
+      @stdout = stdout
+      @stdin = stdin
+      @stderr = stderr
+      @argv = argv
+    end
+
+    def self.available_commands
+      [:check]
+    end
+
+    def setup_global_options
+      true
+    end
+
+    def setup_command
+      @command = argv.shift&.to_sym
+      if CLI.available_commands.include?(@command)
+        true
+      else
+        stderr.puts "Unknown command: #{command}"
+        stderr.puts "  available commands: #{CLI.available_commands.join(', ')}"
+        false
+      end
+    end
+
+    def run
+      setup_global_options or return 1
+      setup_command or return 1
+
+      __send__(:"process_#{command}")
+    end
+
+    def process_check
+      signature_dirs = []
+      verbose = false
+      no_builtin = false
+      dump_all_types = false
+      fallback_any_is_error = false
+
+      OptionParser.new do |opts|
+        opts.on("-I [PATH]") {|path| signature_dirs << Pathname(path) }
+        opts.on("--no-builtin") { no_builtin = true }
+        opts.on("--verbose") { verbose = true }
+        opts.on("--dump-all-types") { dump_all_types = true }
+        opts.on("--fallback-any-is-error") { fallback_any_is_error = true }
+      end.parse!(argv)
+
+      unless no_builtin
+        signature_dirs.unshift Pathname(__dir__).join("../../stdlib").realpath
+      end
+
+      if signature_dirs.empty?
+        signature_dirs << Pathname("sig")
+      end
+
+      source_paths = argv.map {|path| Pathname(path) }
+      if source_paths.empty?
+        source_paths << Pathname(".")
+      end
+
+      Drivers::Check.new(source_paths: source_paths, signature_dirs: signature_dirs, stdout: stdout, stderr: stderr).tap do |check|
+        check.verbose = verbose
+        check.dump_all_types = dump_all_types
+        check.fallback_any_is_error = fallback_any_is_error
+      end.run
+    end
+  end
+end

data/lib/steep/drivers/check.rb

@@ -0,0 +1,141 @@
+module Steep
+  module Drivers
+    class Check
+      attr_reader :source_paths
+      attr_reader :signature_dirs
+      attr_reader :stdout
+      attr_reader :stderr
+
+      attr_accessor :verbose
+      attr_accessor :accept_implicit_any
+      attr_accessor :dump_all_types
+      attr_accessor :fallback_any_is_error
+
+      attr_reader :labeling
+
+      def initialize(source_paths:, signature_dirs:, stdout:, stderr:)
+        @source_paths = source_paths
+        @signature_dirs = signature_dirs
+        @stdout = stdout
+        @stderr = stderr
+
+        self.verbose = false
+        self.accept_implicit_any = false
+        self.dump_all_types = false
+        self.fallback_any_is_error = false
+
+        @labeling = ASTUtils::Labeling.new
+      end
+
+      def run
+        assignability = TypeAssignability.new do |a|
+          each_interface do |signature|
+            a.add_signature(signature)
+          end
+        end
+
+        sources = []
+        each_ruby_source do |source|
+          sources << source
+        end
+
+        typing = Typing.new
+
+        sources.each do |source|
+          stdout.puts "Typechecking #{source.path}..." if verbose
+          annotations = source.annotations(block: source.node) || []
+
+          p annotations if verbose
+
+          construction = TypeConstruction.new(
+            assignability: assignability,
+            annotations: annotations,
+            source: source,
+            var_types: {},
+            self_type: nil,
+            block_context: nil,
+            module_context: TypeConstruction::ModuleContext.new(
+                                                             instance_type: nil,
+                                                             module_type: nil,
+                                                             const_types: annotations.const_types
+            ),
+            method_context: nil,
+            typing: typing,
+          )
+          construction.synthesize(source.node)
+        end
+
+        if dump_all_types
+          lines = []
+
+          typing.nodes.each_value do |node|
+            begin
+              type = typing.type_of(node: node)
+              lines << [node.loc.expression.source_buffer.name, [node.loc.last_line,node.loc.last_column], [node.loc.first_line, node.loc.column], node, type]
+            rescue
+              lines << [node.loc.expression.source_buffer.name, [node.loc.last_line,node.loc.last_column], [node.loc.first_line, node.loc.column], node, nil]
+            end
+          end
+
+          lines.sort {|x,y| y <=> x }.reverse_each do |line|
+            source = line[3].loc.expression.source
+            stdout.puts "#{line[0]}:(#{line[2].join(",")}):(#{line[1].join(",")}):\t#{line[3].type}:\t#{line[4]}\t(#{source.split(/\n/).first})"
+          end
+        end
+
+        typing.errors.each do |error|
+          next if error.is_a?(Errors::FallbackAny) && !fallback_any_is_error
+          stdout.puts error.to_s
+        end
+      end
+
+      def each_interface
+        signature_dirs.each do |path|
+          if path.file?
+            stdout.puts "Loading signature #{path}..." if verbose
+            Parser.parse_signature(path.read).each do |interface|
+              yield interface
+            end
+          end
+
+          if path.directory?
+            each_file_in_dir(".rbi", path) do |file|
+              stdout.puts "Loading signature #{file}..." if verbose
+              Parser.parse_signature(file.read).each do |interface|
+                yield interface
+              end
+            end
+          end
+        end
+      end
+
+      def each_ruby_source
+        source_paths.each do |path|
+          if path.file?
+            stdout.puts "Loading Ruby program #{path}..." if verbose
+            yield Source.parse(path.read, path: path.to_s, labeling: labeling)
+          end
+
+          if path.directory?
+            each_file_in_dir(".rb", path) do |file|
+              stdout.puts "Loading Ruby program #{file}..." if verbose
+              yield Source.parse(file.read, path: file.to_s, labeling: labeling)
+            end
+          end
+        end
+      end
+
+      def each_file_in_dir(suffix, path, &block)
+        path.children.each do |child|
+          if child.directory?
+            each_file_in_dir(suffix, child, &block)
+          end
+
+          if child.file? && suffix == child.extname
+            yield child
+          end
+        end
+      end
+    end
+  end
+end

data/lib/steep/errors.rb

@@ -0,0 +1,207 @@
+module Steep
+  module Errors
+    class Base
+      attr_reader :node
+
+      def initialize(node:)
+        @node = node
+      end
+
+      def location_to_str
+        "#{node.loc.expression.source_buffer.name}:#{node.loc.first_line}:#{node.loc.column}"
+      end
+    end
+
+    class IncompatibleAssignment < Base
+      attr_reader :lhs_type
+      attr_reader :rhs_type
+
+      def initialize(node:, lhs_type:, rhs_type:)
+        super(node: node)
+        @lhs_type = lhs_type
+        @rhs_type = rhs_type
+      end
+
+      def to_s
+        "#{location_to_str}: IncompatibleAssignment: lhs_type=#{lhs_type}, rhs_type=#{rhs_type}"
+      end
+    end
+
+    class ArgumentTypeMismatch < Base
+      attr_reader :type
+      attr_reader :method
+
+      def initialize(node:, type:, method:)
+        super(node: node)
+        @type = type
+        @method = method
+      end
+
+      def to_s
+        "#{location_to_str}: ArgumentTypeMismatch: type=#{type}, method=#{method}"
+      end
+    end
+
+    class NoMethod < Base
+      attr_reader :type
+      attr_reader :method
+
+      def initialize(node:, type:, method:)
+        super(node: node)
+        @type = type
+        @method = method
+      end
+
+      def to_s
+        "#{location_to_str}: NoMethodError: type=#{type}, method=#{method}"
+      end
+    end
+
+    class ReturnTypeMismatch < Base
+      attr_reader :expected
+      attr_reader :actual
+
+      def initialize(node:, expected:, actual:)
+        super(node: node)
+        @expected = expected
+        @actual = actual
+      end
+
+      def to_s
+        "#{location_to_str}: ReturnTypeMismatch: expected=#{expected}, actual=#{actual}"
+      end
+    end
+
+    class UnexpectedBlockGiven < Base
+      attr_reader :method
+      attr_reader :type
+
+      def initialize(node:, type:, method:)
+        super(node: node)
+        @type = type
+        @method = method
+      end
+    end
+
+    class BlockTypeMismatch < Base
+      attr_reader :expected
+      attr_reader :actual
+
+      def initialize(node:, expected:, actual:)
+        super(node: node)
+        @expected = expected
+        @actual = actual
+      end
+
+      def to_s
+        "#{location_to_str}: BlockTypeMismatch: expected=#{expected}, actual=#{actual}"
+      end
+    end
+
+    class BreakTypeMismatch < Base
+      attr_reader :expected
+      attr_reader :actual
+
+      def initialize(node:, expected:, actual:)
+        super(node: node)
+        @expected = expected
+        @actual = actual
+      end
+    end
+
+    class MethodParameterTypeMismatch < Base
+      def to_s
+        "#{location_to_str}: MethodParameterTypeMismatch: method=#{node.children[0]}"
+      end
+    end
+
+    class MethodBodyTypeMismatch < Base
+      attr_reader :expected
+      attr_reader :actual
+
+      def initialize(node:, expected:, actual:)
+        super(node: node)
+        @expected = expected
+        @actual = actual
+      end
+
+      def to_s
+        method = case node.type
+                 when :def
+                   node.children[0]
+                 when :defs
+                   prefix = node.children[0].type == :self ? "self" : "*"
+                   "#{prefix}.#{node.children[1]}"
+                 end
+        "#{location_to_str}: MethodBodyTypeMismatch: method=#{method}, expected=#{expected}, actual=#{actual}"
+      end
+    end
+
+    class UnexpectedYield < Base
+      def to_s
+        "#{location_to_str}: UnexpectedYield"
+      end
+    end
+
+    class UnexpectedSuper < Base
+      attr_reader :method
+
+      def initialize(node:, method:)
+        super(node: node)
+        @method = method
+      end
+
+      def to_s
+        "#{location_to_str}: UnexpectedSuper: method=#{method}"
+      end
+    end
+
+    class MethodDefinitionMissing < Base
+      attr_reader :module_name
+      attr_reader :kind
+      attr_reader :missing_method
+
+      def initialize(node:, module_name:, kind:, missing_method:)
+        super(node: node)
+        @module_name = module_name
+        @kind = kind
+        @missing_method = missing_method
+      end
+
+      def to_s
+        method = case kind
+                 when :instance
+                   "#{missing_method}"
+                 when :module
+                   "self.#{missing_method}"
+                 end
+        "#{location_to_str}: MethodDefinitionMissing: module=#{module_name}, method=#{method}"
+      end
+    end
+
+    class UnexpectedDynamicMethod < Base
+      attr_reader :module_name
+      attr_reader :method_name
+
+      def initialize(node:, module_name:, method_name:)
+        @node = node
+        @module_name = module_name
+        @method_name = method_name
+      end
+
+      def to_s
+        "#{location_to_str}: UnexpectedDynamicMethod: module=#{module_name}, method=#{method_name}"
+      end
+    end
+
+    class FallbackAny < Base
+      def initialize(node:)
+        @node = node
+      end
+
+      def to_s
+        "#{location_to_str}: FallbackAny"
+      end
+    end
+  end
+end

data/lib/steep/interface.rb

@@ -0,0 +1,280 @@
+module Steep
+  class Interface
+    class Params
+      attr_reader :required
+      attr_reader :optional
+      attr_reader :rest
+      attr_reader :required_keywords
+      attr_reader :optional_keywords
+      attr_reader :rest_keywords
+
+      def initialize(required:, optional:, rest:, required_keywords:, optional_keywords:, rest_keywords:)
+        @required = required
+        @optional = optional
+        @rest = rest
+        @required_keywords = required_keywords
+        @optional_keywords = optional_keywords
+        @rest_keywords = rest_keywords
+      end
+
+      def with(required: nil, optional: nil, rest: nil, required_keywords: nil, optional_keywords: nil, rest_keywords: nil)
+        self.class.new(required: required || self.required,
+                       optional: optional || self.optional,
+                       rest: rest || self.rest,
+                       required_keywords: required_keywords || self.required_keywords,
+                       optional_keywords: optional_keywords || self.optional_keywords,
+                       rest_keywords: rest_keywords || self.rest_keywords)
+      end
+
+      def self.empty
+        new(required: [], optional: [], rest: nil, required_keywords: {}, optional_keywords: {}, rest_keywords: nil)
+      end
+
+      def ==(other)
+        other.is_a?(self.class) &&
+          other.required == required &&
+          other.optional == optional &&
+          other.rest == rest &&
+          other.required_keywords == required_keywords &&
+          other.optional_keywords == optional_keywords &&
+          other.rest_keywords == rest_keywords
+      end
+
+      def flat_unnamed_params
+        required.map {|p| [:required, p] } + optional.map {|p| [:optional, p] }
+      end
+
+      def flat_keywords
+        required_keywords.merge optional_keywords
+      end
+
+      def has_keywords?
+        !required_keywords.empty? || !optional_keywords.empty? || rest_keywords
+      end
+
+      def each_missing_argument(args)
+        required.size.times do |index|
+          if index >= args.size
+            yield index
+          end
+        end
+      end
+
+      def each_extra_argument(args)
+        return if rest
+
+        if has_keywords?
+          args = args.take(args.count - 1) if args.count > 0
+        end
+
+        args.size.times do |index|
+          if index >= required.count + optional.count
+            yield index
+          end
+        end
+      end
+
+      def each_missing_keyword(args)
+        return unless has_keywords?
+
+        keywords, rest = extract_keywords(args)
+
+        return unless rest.empty?
+
+        required_keywords.each do |keyword, _|
+          yield keyword unless keywords.key?(keyword)
+        end
+      end
+
+      def each_extra_keyword(args)
+        return unless has_keywords?
+        return if rest_keywords
+
+        keywords, rest = extract_keywords(args)
+
+        return unless rest.empty?
+
+        all_keywords = flat_keywords
+        keywords.each do |keyword, _|
+          yield keyword unless all_keywords.key?(keyword)
+        end
+      end
+
+      def extract_keywords(args)
+        last_arg = args.last
+
+        keywords = {}
+        rest = []
+
+        if last_arg&.type == :hash
+          last_arg.children.each do |element|
+            case element.type
+            when :pair
+              if element.children[0].type == :sym
+                name = element.children[0].children[0]
+                keywords[name] = element.children[1]
+              end
+            when :kwsplat
+              rest << element.children[0]
+            end
+          end
+        end
+
+        [keywords, rest]
+      end
+
+      def each_type()
+        if block_given?
+          flat_unnamed_params.each do |(_, type)|
+            yield type
+          end
+          flat_keywords.each do |_, type|
+            yield type
+          end
+          rest and yield rest
+          rest_keywords and yield rest_keywords
+        else
+          enum_for :each_type
+        end
+      end
+
+      def closed?
+        required.all?(&:closed?) && optional.all?(&:closed?) && (!rest || rest.closed?) && required_keywords.values.all?(&:closed?) && optional_keywords.values.all?(&:closed?) && (!rest_keywords || rest_keywords.closed?)
+      end
+
+      def substitute(klass:, instance:, params:)
+        self.class.new(required: required.map {|t| t.substitute(klass: klass, instance: instance, params: params) },
+                       optional: optional.map {|t| t.substitute(klass: klass, instance: instance, params: params) },
+                       rest: rest&.substitute(klass: klass, instance: instance, params: params),
+                       required_keywords: required_keywords.transform_values {|t| t.substitute(klass: klass, instance: instance, params: params) },
+                       optional_keywords: optional_keywords.transform_values {|t| t.substitute(klass: klass, instance: instance, params: params) },
+                       rest_keywords: rest_keywords&.substitute(klass: klass, instance: instance, params: params) )
+      end
+
+      def size
+        required.size + optional.size + (rest ? 1 : 0) + required_keywords.size + optional_keywords.size + (rest_keywords ? 1 : 0)
+      end
+    end
+
+    class MethodType
+      attr_reader :type_params
+      attr_reader :params
+      attr_reader :block
+      attr_reader :return_type
+
+      NONE = Object.new
+
+      def initialize(type_params:, params:, block:, return_type:)
+        @type_params = type_params
+        @params = params
+        @block = block
+        @return_type = return_type
+      end
+
+      def updated(type_params: NONE, params: NONE, block: NONE, return_type: 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)
+      end
+
+      def ==(other)
+        other.is_a?(self.class) &&
+          other.params == params &&
+          other.block == block &&
+          other.return_type == return_type
+      end
+
+      def closed?
+        params.closed? && (!block || block.closed?) && return_type.closed?
+      end
+
+      def substitute(klass:, instance:, params:)
+        self.class.new(type_params: type_params,
+                       params: self.params.substitute(klass: klass, instance: instance, params: params),
+                       block: block&.substitute(klass: klass, instance: instance, params: params),
+                       return_type: return_type.substitute(klass: klass, instance: instance, params: params))
+      end
+
+      def instantiate(subst:)
+        raise "Open method type cannot be instantiated" unless closed?
+
+        self.class.new(type_params: type_params.reject {|param| subst.key?(param) },
+                       params: self.params.substitute(klass: nil, instance: nil, params: subst),
+                       block: block&.substitute(klass: nil, instance: nil, params: subst),
+                       return_type: return_type.substitute(klass: nil, instance: nil, params: subst))
+      end
+    end
+
+    class Block
+      attr_reader :params
+      attr_reader :return_type
+
+      def initialize(params:, return_type:)
+        @params = params
+        @return_type = return_type
+      end
+
+      def ==(other)
+        other.is_a?(self.class) && other.params == params && other.return_type == return_type
+      end
+
+      def closed?
+        params.closed? && return_type.closed?
+      end
+
+      def substitute(klass:, instance:, params:)
+        self.class.new(params: self.params.substitute(klass: klass, instance: instance, params: params),
+                       return_type: return_type.substitute(klass: klass, instance: instance, params: params))
+      end
+    end
+
+    class Method
+      attr_reader :super_method
+      attr_reader :types
+
+      def initialize(types:, super_method:)
+        @types = types
+        @super_method = super_method
+      end
+
+      def ==(other)
+        other.is_a?(Method) && other.types == types && other.super_method == super_method
+      end
+
+      def closed?
+        types.all?(&:closed?)
+      end
+
+      def substitute(klass:, instance:, params:)
+        self.class.new(
+          types: types.map {|type| type.substitute(klass: klass, instance: instance, params: params) },
+          super_method: super_method&.substitute(klass: klass, instance: instance, params: params)
+        )
+      end
+
+      def map_types()
+        self.class.new(
+          types: types.map {|type| yield(type) },
+          super_method: super_method
+        )
+      end
+    end
+
+    attr_reader :name
+    attr_reader :methods
+
+    def initialize(name:, methods:)
+      @name = name
+      @methods = methods
+    end
+
+    def closed?
+      methods.values.all?(&:closed?)
+    end
+
+    def ==(other)
+      other.is_a?(self.class) && other.name == name && other.methods == methods
+    end
+  end
+end