steep 0.1.0.pre2 → 0.1.0

data/lib/steep/drivers/check.rb

@@ -13,6 +13,8 @@ module Steep
 
       attr_reader :labeling
 
+      include Utils::EachSignature
+
       def initialize(source_paths:, signature_dirs:, stdout:, stderr:)
         @source_paths = source_paths
         @signature_dirs = signature_dirs
@@ -28,45 +30,67 @@ module Steep
       end
 
       def run
-        assignability = TypeAssignability.new do |a|
-          each_interface do |signature|
-            a.add_signature(signature)
-          end
+        Steep.logger.level = Logger::DEBUG if verbose
+
+        env = AST::Signature::Env.new
+
+        each_signature(signature_dirs, verbose) do |signature|
+          env.add signature
+        end
+
+        builder = Interface::Builder.new(signatures: env)
+        check = Subtyping::Check.new(builder: builder)
+
+        validator = Utils::Validator.new(stdout: stdout, stderr: stderr, verbose: verbose)
+
+        validated = validator.run(env: env, builder: builder, check: check) do |sig|
+          stderr.puts "Validating #{sig.name} (#{sig.location.name}:#{sig.location.start_line})..." if verbose
         end
 
-        assignability.errors.each do |error|
-          error.puts(stdout)
+        unless validated
+          return 1
         end
 
         sources = []
-        each_ruby_source do |source|
+        each_ruby_source(source_paths, verbose) 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)
+          Steep.logger.tagged source.path do
+            Steep.logger.debug "Typechecking..."
+            annotations = source.annotations(block: source.node) || []
+
+            pp annotations if verbose
+
+            const_env = TypeInference::ConstantEnv.new(builder: check.builder, current_namespace: nil)
+            type_env = TypeInference::TypeEnv.build(annotations: annotations,
+                                                    subtyping: check,
+                                                    const_env: const_env,
+                                                    signatures: check.builder.signatures)
+
+            construction = TypeConstruction.new(
+              checker: check,
+              annotations: annotations,
+              source: source,
+              self_type: AST::Types::Name.new_instance(name: "::Object"),
+              block_context: nil,
+              module_context: TypeConstruction::ModuleContext.new(
+                instance_type: nil,
+                module_type: nil,
+                implement_name: nil,
+                current_namespace: nil,
+                const_env: const_env
+              ),
+              method_context: nil,
+              typing: typing,
+              break_context: nil,
+              type_env: type_env
+              )
+            construction.synthesize(source.node)
+          end
         end
 
         if dump_all_types
@@ -89,55 +113,7 @@ module Steep
 
         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
+          error.print_to stdout
         end
       end
     end

data/lib/steep/drivers/scaffold.rb

@@ -0,0 +1,303 @@
+module Steep
+  module Drivers
+    class Scaffold
+      attr_reader :source_paths
+      attr_reader :stdout
+      attr_reader :stderr
+      attr_reader :labeling
+
+      include Utils::EachSignature
+
+      def initialize(source_paths:, stdout:, stderr:)
+        @source_paths = source_paths
+        @stdout = stdout
+        @stderr = stderr
+
+        @labeling = ASTUtils::Labeling.new
+      end
+
+      def run
+        each_ruby_source(source_paths, false) do |source|
+          Generator.new(source: source, stderr: stderr).write(io: stdout)
+        end
+      end
+
+      class Generator
+        class Module
+          attr_reader :name
+          attr_reader :methods
+          attr_reader :singleton_methods
+          attr_reader :ivars
+          attr_reader :kind
+
+          def initialize(name:, kind:)
+            @kind = kind
+            @name = name
+            @ivars = {}
+            @methods = {}
+            @singleton_methods = {}
+          end
+
+          def class?
+            kind == :class
+          end
+
+          def module?
+            kind == :module
+          end
+        end
+
+        attr_reader :source
+        attr_reader :modules
+        attr_reader :constants
+        attr_reader :stderr
+
+        def initialize(source:, stderr:)
+          @source = source
+          @stderr = stderr
+          @modules = []
+          @constants = {}
+        end
+
+        def write(io:)
+          generate(source.node, current_path: [])
+
+          modules.each do |mod|
+            unless mod.methods.empty? && mod.singleton_methods.empty?
+              io.puts "#{mod.kind} #{mod.name}"
+
+              mod.ivars.each do |name, type|
+                io.puts "  #{name}: #{type}"
+              end
+
+              mod.methods.each do |name, type|
+                io.puts "  def #{name}: #{type}"
+              end
+
+              mod.singleton_methods.each do |name, type|
+                io.puts "  def self.#{name}: #{type}"
+              end
+
+              io.puts "end"
+              io.puts
+            end
+          end
+
+          constants.each do |name, ty|
+            io.puts "#{name}: #{ty}"
+          end
+        end
+
+        def module_name(name)
+          if name.type == :const
+            prefix = name.children[0]
+            if prefix
+              "#{module_name(prefix)}::#{name.children[1]}"
+            else
+              name.children[1].to_s
+            end
+          else
+            stderr.puts "Unexpected node for class name: #{name}"
+            return "____"
+          end
+        end
+
+        def full_name(current_path, name)
+          (current_path + [name]).join("::")
+        end
+
+        def generate(node, current_path:, current_module: nil, is_instance_method: false)
+          case node.type
+          when :module
+            name = module_name(node.children[0])
+            mod = Module.new(name: full_name(current_path, name), kind: :module)
+            modules << mod
+
+            if node.children[1]
+              generate(node.children[1],
+                       current_path: current_path + [name],
+                       current_module: mod)
+            end
+
+          when :class
+            name = module_name(node.children[0])
+            klass = Module.new(name: full_name(current_path, name), kind: :class)
+            modules << klass
+
+            if node.children[2]
+              generate(node.children[2],
+                       current_path: current_path + [name],
+                       current_module: klass)
+            end
+
+          when :def
+            name, args, body = node.children
+
+            if current_module
+              current_module.methods[name] = "(#{arg_types(args)}) -> #{guess_type(body)}"
+            end
+
+            if body
+              generate(body,
+                       current_path: current_path,
+                       current_module: current_module,
+                       is_instance_method: true)
+            end
+
+          when :ivar, :ivasgn
+            name = node.children[0]
+
+            if current_module && is_instance_method
+              current_module.ivars[name] = guess_type(node.children[1])
+            end
+
+            each_child_node(node) do |child|
+              generate(child,
+                       current_path: current_path,
+                       current_module: current_module,
+                       is_instance_method: is_instance_method)
+            end
+
+          when :defs
+            if node.children[0].type == :self
+              _, name, args, body = node.children
+
+              if current_module
+                current_module.singleton_methods[name] = "(#{arg_types(args)}) -> #{guess_type(body)}"
+              end
+
+              if body
+                generate(body,
+                         current_path: current_path,
+                         current_module: current_module,
+                         is_instance_method: false)
+              end
+            end
+
+          when :casgn
+            if node.children[0]
+              stderr.puts "Unexpected casgn: #{node}, #{node.loc.line}"
+            end
+
+            constants[full_name(current_path, node.children[1])] = guess_type(node.children[2])
+
+            if node.children[2]
+              generate(node.children[2],
+                       current_path: current_path,
+                       current_module: current_module,
+                       is_instance_method: is_instance_method)
+            end
+
+          else
+            each_child_node(node) do |child|
+              generate(child, current_path: current_path, current_module: current_module, is_instance_method: is_instance_method)
+            end
+          end
+        end
+
+        def guess_type(node)
+          return "any" unless node
+          case node.type
+          when :false, :true
+            "_Boolean"
+          when :int
+            "Integer"
+          when :float
+            "Float"
+          when :complex
+            "Complex"
+          when :rational
+            "Rational"
+          when :str, :dstr, :xstr
+            "String"
+          when :sym, :dsym
+            "Symbol"
+          when :regexp
+            "Regexp"
+          when :array
+            "Array<any>"
+          when :hash
+            "Hash<any, any>"
+          when :irange, :erange
+            "Range<any>"
+          when :lvasgn, :ivasgn, :cvasgn, :gvasgn, :casgn
+            guess_type(node.children.last)
+          when :send
+            if node.children[1] == :[]=
+              guess_type(node.children.last)
+            else
+              "any"
+            end
+          when :begin
+            # should support shortcut return?
+            guess_type(node.children.last)
+          when :return
+            children = node.children
+            if children.size == 1
+              guess_type(node.children.last)
+            else
+              "Array<any>" # or Tuple or any?
+            end
+          when :if
+            children = node.children
+            if children[2]
+              ty1 = guess_type(children[1])
+              ty2 = guess_type(children[2])
+              if ty1 == ty2
+                ty1
+              else
+                "any"
+              end
+            else
+              "void" # assuming no-else if statement implies void
+            end
+          when :while, :until, :while_post, :until_post, :for
+            "void"
+          when :case
+            children = node.children
+            if children.last
+              ty = guess_type(children.last)
+              children[1..-2].each do |child|
+                return "any" if ty != guess_type(child.children.last)
+              end
+              ty
+            else
+              "any"
+            end
+          when :masgn
+            "void" # assuming masgn implies void
+          else
+            "any"
+          end
+        end
+
+        def each_child_node(node, &block)
+          node.children.each do |child|
+            if child.is_a?(::AST::Node)
+              yield child
+            end
+          end
+        end
+
+        def arg_types(args)
+          args.children.map do |arg|
+            case arg.type
+            when :arg
+              "any"
+            when :optarg
+              "?#{guess_type(arg.children[1])}"
+            when :restarg
+              "*any"
+            when :kwarg
+              "#{arg.children.first.name}: any"
+            when :kwoptarg
+              "?#{arg.children.first.name}: #{guess_type(arg.children[1])}"
+            when :kwrestarg
+              "**any"
+            end
+          end.compact.join(", ")
+        end
+      end
+    end
+  end
+end

data/lib/steep/drivers/utils/each_signature.rb

@@ -0,0 +1,66 @@
+module Steep
+  module Drivers
+    module Utils
+      module EachSignature
+        def each_signature(signature_dirs, verbose)
+          signature_dirs.each do |path|
+            if path.file?
+              stderr.puts "Loading signature #{path}..." if verbose
+              Parser.parse_signature(path.read, name: path).each do |signature|
+                yield signature
+              end
+            end
+
+            if path.directory?
+              each_file_in_dir(".rbi", path) do |file|
+                stderr.puts "Loading signature #{file}..." if verbose
+                Parser.parse_signature(file.read, name: file).each do |signature|
+                  yield signature
+                end
+              end
+            end
+          end
+        end
+
+        def each_ruby_source(source_paths, verbose)
+          each_ruby_file source_paths do |file|
+            begin
+              stdout.puts "Loading Ruby program #{file}..." if verbose
+              if (source = Source.parse(file.read, path: file.to_s, labeling: labeling))
+                yield source
+              end
+            rescue => exn
+              Steep.logger.error "Error occured on parsing #{file}: #{exn.inspect}"
+            end
+          end
+        end
+
+        def each_ruby_file(source_paths)
+          source_paths.each do |path|
+            if path.file?
+              yield path
+            end
+
+            if path.directory?
+              each_file_in_dir(".rb", path) do |file|
+                yield file
+              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
+end

data/lib/steep/drivers/utils/validator.rb

@@ -0,0 +1,115 @@
+module Steep
+  module Drivers
+    module Utils
+      class Validator
+        attr_reader :stdout
+        attr_reader :stderr
+        attr_reader :verbose
+
+        def initialize(stdout:, stderr:, verbose:)
+          @stdout = stdout
+          @stderr = stderr
+          @verbose = verbose
+        end
+
+        def run(env:, builder:, check:)
+          result = true
+
+          env.each do |sig|
+            yield sig if block_given?
+
+            case sig
+            when AST::Signature::Interface
+              yield_self do
+                instance_name = TypeName::Interface.new(name: sig.name)
+                instance_interface = builder.build(instance_name)
+
+                args = instance_interface.params.map {|var| AST::Types::Var.fresh(var) }
+                instance_type = AST::Types::Name.new_interface(name: sig.name, args: args)
+
+                instance_interface.instantiate(type: instance_type,
+                                               args: args,
+                                               instance_type: instance_type,
+                                               module_type: nil).validate(check)
+              end
+
+            when AST::Signature::Module
+              yield_self do
+                instance_name = TypeName::Instance.new(name: sig.name)
+                instance_interface = builder.build(instance_name)
+                instance_args = instance_interface.params.map {|var| AST::Types::Var.fresh(var) }
+
+                module_name = TypeName::Module.new(name: sig.name)
+                module_interface = builder.build(module_name)
+                module_args = module_interface.params.map {|var| AST::Types::Var.fresh(var) }
+
+                instance_type = AST::Types::Name.new_instance(name: sig.name, args: instance_args)
+                module_type = AST::Types::Name.new_module(name: sig.name, args: module_args)
+
+                stdout.puts "👀 Validating instance methods..." if verbose
+                instance_interface.instantiate(type: instance_type,
+                                               args: instance_args,
+                                               instance_type: instance_type,
+                                               module_type: module_type).validate(check)
+
+                stdout.puts "👀 Validating class methods..." if verbose
+                module_interface.instantiate(type: module_type,
+                                             args: module_args,
+                                             instance_type: instance_type,
+                                             module_type: module_type).validate(check)
+              end
+
+            when AST::Signature::Class
+              yield_self do
+                instance_name = TypeName::Instance.new(name: sig.name)
+                instance_interface = builder.build(instance_name)
+                instance_args = instance_interface.params.map {|var| AST::Types::Var.fresh(var) }
+
+                module_name = TypeName::Class.new(name: sig.name, constructor: nil)
+                module_interface = builder.build(module_name)
+                module_args = module_interface.params.map {|var| AST::Types::Var.fresh(var) }
+
+                instance_type = AST::Types::Name.new_instance(name: sig.name, args: instance_args)
+                module_type = AST::Types::Name.new_class(name: sig.name, args: module_args, constructor: nil)
+
+                stdout.puts "👀 Validating instance methods..." if verbose
+                instance_interface.instantiate(type: instance_type,
+                                               args: instance_args,
+                                               instance_type: instance_type,
+                                               module_type: module_type).validate(check)
+
+                stdout.puts "👀 Validating class methods..." if verbose
+                module_interface.instantiate(type: module_type,
+                                             args: module_args,
+                                             instance_type: instance_type,
+                                             module_type: module_type).validate(check)
+              end
+            end
+
+          rescue Interface::Instantiated::InvalidMethodOverrideError => exn
+            result = false
+            stdout.puts "😱 #{exn.message}"
+            exn.result.trace.each do |s, t|
+              case s
+              when Interface::Method
+                stdout.puts "  #{s.name}(#{s.type_name}) <: #{t.name}(#{t.type_name})"
+              when Interface::MethodType
+                stdout.puts "  #{s.location.source} <: #{t.location.source} (#{s.location.name}:#{s.location.start_line})"
+              else
+                stdout.puts "  #{s} <: #{t}"
+              end
+            end
+            stdout.puts "  🚨 #{exn.result.error.message}"
+
+          rescue Interface::Instantiated::InvalidIvarOverrideError => exn
+            result = false
+            stdout.puts "😱 #{exn.message}"
+
+          end
+
+          result
+        end
+      end
+    end
+  end
+end

data/lib/steep/drivers/validate.rb

@@ -0,0 +1,39 @@
+module Steep
+  module Drivers
+    class Validate
+      attr_reader :signature_dirs
+      attr_reader :stdout
+      attr_reader :stderr
+      attr_accessor :verbose
+
+      def initialize(signature_dirs:, stdout:, stderr:)
+        @signature_dirs = signature_dirs
+        @stdout = stdout
+        @stderr = stderr
+
+        self.verbose = false
+      end
+
+      include Utils::EachSignature
+
+      def run
+        Steep.logger.level = Logger::DEBUG if verbose
+
+        env = AST::Signature::Env.new
+
+        each_signature(signature_dirs, verbose) do |signature|
+          env.add signature
+        end
+
+        builder = Interface::Builder.new(signatures: env)
+        check = Subtyping::Check.new(builder: builder)
+
+        validator = Utils::Validator.new(stdout: stdout, stderr: stderr, verbose: verbose)
+
+        validator.run(env: env, builder: builder, check: check) do |sig|
+          stderr.puts "Validating #{sig.name} (#{sig.location.name}:#{sig.location.start_line})..." if verbose
+        end
+      end
+    end
+  end
+end