steep 0.1.0.pre2 → 0.1.0

data/lib/steep/ast/types/instance.rb

@@ -0,0 +1,39 @@
+module Steep
+  module AST
+    module Types
+      class Instance
+        attr_reader :location
+
+        def initialize(location: nil)
+          @location = location
+        end
+
+        def ==(other)
+          other.is_a?(Instance)
+        end
+
+        def hash
+          self.class.hash
+        end
+
+        alias eql? ==
+
+        def subst(s)
+          s.instance_type or raise "Unexpected substitution: #{inspect}"
+        end
+
+        def free_variables
+          Set.new
+        end
+
+        def to_s
+          "instance"
+        end
+
+        def level
+          [0]
+        end
+      end
+    end
+  end
+end

data/lib/steep/ast/types/intersection.rb

@@ -0,0 +1,74 @@
+module Steep
+  module AST
+    module Types
+      class Intersection
+        attr_reader :types
+        attr_reader :location
+
+        def initialize(types:, location: nil)
+          @types = types
+          @location = location
+        end
+
+        def self.build(types:, location: nil)
+          types.flat_map do |type|
+            if type.is_a?(Intersection)
+              type.types
+            else
+              [type]
+            end
+          end.map do |type|
+            case type
+            when AST::Types::Any
+              return AST::Types::Any.new()
+            when AST::Types::Bot
+              return AST::Types::Bot.new()
+            when AST::Types::Top
+              nil
+            else
+              type
+            end
+          end.compact.uniq.yield_self do |tys|
+            if tys.size == 1
+              tys.first
+            else
+              new(types: tys.sort_by(&:hash), location: location)
+            end
+          end
+        end
+
+        def ==(other)
+          other.is_a?(Intersection) &&
+            other.types == types
+        end
+
+        def hash
+          self.class.hash ^ types.hash
+        end
+
+        alias eql? ==
+
+        def subst(s)
+          self.class.build(location: location,
+                           types: types.map {|ty| ty.subst(s) })
+        end
+
+        def to_s
+          "(#{types.map(&:to_s).sort.join(" & ")})"
+        end
+
+        def free_variables
+          types.each.with_object(Set.new) do |type, set|
+            set.merge(type.free_variables)
+          end
+        end
+
+        include Helper::ChildrenLevel
+
+        def level
+          [0] + level_of_children(types)
+        end
+      end
+    end
+  end
+end

data/lib/steep/ast/types/name.rb

@@ -0,0 +1,124 @@
+module Steep
+  module AST
+    module Types
+      class Name
+        attr_reader :location
+        attr_reader :name
+        attr_reader :args
+
+        def initialize(name:, args:, location: nil)
+          @location = location
+          @name = name
+          @args = args
+        end
+
+        def ==(other)
+          other.is_a?(Name) &&
+            other.name == name &&
+            other.args == args
+        end
+
+        def hash
+          self.class.hash ^ name.hash ^ args.hash
+        end
+
+        alias eql? ==
+
+        def to_s
+          if args.empty?
+            "#{name}"
+          else
+            "#{name}<#{args.join(", ")}>"
+          end
+        end
+
+        def self.new_module(location: nil, name:, args: [])
+          name = ModuleName.parse(name) unless name.is_a?(ModuleName)
+          new(location: location,
+              name: TypeName::Module.new(name: name),
+              args: args)
+        end
+
+        def self.new_class(location: nil, name:, constructor:, args: [])
+          name = ModuleName.parse(name) unless name.is_a?(ModuleName)
+          new(location: location,
+              name: TypeName::Class.new(name: name, constructor: constructor),
+              args: args)
+        end
+
+        def self.new_instance(location: nil, name:, args: [])
+          name = ModuleName.parse(name) unless name.is_a?(ModuleName)
+          new(location: location,
+              name: TypeName::Instance.new(name: name),
+              args: args)
+        end
+
+        def self.new_interface(location: nil, name:, args: [])
+          new(location: location, name: TypeName::Interface.new(name: name), args: args)
+        end
+
+        def subst(s)
+          self.class.new(location: location,
+                         name: name,
+                         args: args.map {|a| a.subst(s) })
+        end
+
+        def instance_type
+          case name
+          when TypeName::Interface, TypeName::Instance
+            self
+          when TypeName::Module, TypeName::Class
+            self.class.new_instance(location: location,
+                                    name: name.name,
+                                    args: args)
+          else
+            raise "Unknown name: #{name.inspect}"
+          end
+        end
+
+        def class_type(constructor:)
+          case name
+          when TypeName::Instance
+            self.class.new_class(location: location,
+                                 name: name.name,
+                                 constructor: constructor,
+                                 args: [])
+          when TypeName::Class
+            self
+          when TypeName::Module, TypeName::Interface
+            raise "Cannot make class type: #{inspect}"
+          else
+            raise "Unknown name: #{name.inspect}"
+          end
+        end
+
+        def module_type
+          case name
+          when TypeName::Instance,
+            self.class.new_module(location: location,
+                                  name: name.name,
+                                  args: args)
+          when TypeName::Module
+            self
+          when TypeName::Class, TypeName::Interface
+            raise "Cannot make module type: #{inspect}"
+          else
+            raise "Unknown name: #{name.inspect}"
+          end
+        end
+
+        def free_variables
+          self.args.each.with_object(Set.new) do |type, vars|
+            vars.merge(type.free_variables)
+          end
+        end
+
+        include Helper::ChildrenLevel
+
+        def level
+          [0] + level_of_children(args)
+        end
+      end
+    end
+  end
+end

data/lib/steep/ast/types/self.rb

@@ -0,0 +1,39 @@
+module Steep
+  module AST
+    module Types
+      class Self
+        attr_reader :location
+
+        def initialize(location: nil)
+          @location = location
+        end
+
+        def ==(other)
+          other.is_a?(Self)
+        end
+
+        def hash
+          self.class.hash
+        end
+
+        alias eql? ==
+
+        def to_s
+          "self"
+        end
+
+        def subst(s)
+          s.self_type or raise "Unexpected substitution: #{inspect}"
+        end
+
+        def free_variables
+          Set.new
+        end
+
+        def level
+          [0]
+        end
+      end
+    end
+  end
+end

data/lib/steep/ast/types/top.rb

@@ -0,0 +1,39 @@
+module Steep
+  module AST
+    module Types
+      class Top
+        attr_reader :location
+
+        def initialize(location: nil)
+          @location = location
+        end
+
+        def ==(other)
+          other.is_a?(Top)
+        end
+
+        def hash
+          self.class.hash
+        end
+
+        alias eql? ==
+
+        def subst(s)
+          self
+        end
+
+        def to_s
+          "⟙"
+        end
+
+        def free_variables
+          Set.new
+        end
+
+        def level
+          [2]
+        end
+      end
+    end
+  end
+end

data/lib/steep/ast/types/union.rb

@@ -0,0 +1,74 @@
+module Steep
+  module AST
+    module Types
+      class Union
+        attr_reader :types
+        attr_reader :location
+
+        def initialize(types:, location: nil)
+          @types = types
+          @location = location
+        end
+
+        def self.build(types:, location: nil)
+          types.flat_map do |type|
+            if type.is_a?(Union)
+              type.types
+            else
+              [type]
+            end
+          end.map do |type|
+            case type
+            when AST::Types::Any
+              return AST::Types::Any.new()
+            when AST::Types::Top
+              return AST::Types::Top.new()
+            when AST::Types::Bot
+              nil
+            else
+              type
+            end
+          end.compact.uniq.yield_self do |tys|
+            if tys.length == 1
+              tys.first
+            else
+              new(types: tys.sort_by(&:hash), location: location)
+            end
+          end
+        end
+
+        def ==(other)
+          other.is_a?(Union) &&
+            other.types == types
+        end
+
+        def hash
+          self.class.hash ^ types.hash
+        end
+
+        alias eql? ==
+
+        def subst(s)
+          self.class.build(location: location,
+                           types: types.map {|ty| ty.subst(s) })
+        end
+
+        def to_s
+          "(#{types.map(&:to_s).sort.join(" | ")})"
+        end
+
+        def free_variables
+          types.each.with_object(Set.new) do |type, set|
+            set.merge(type.free_variables)
+          end
+        end
+
+        include Helper::ChildrenLevel
+
+        def level
+          [0] + level_of_children(types)
+        end
+      end
+    end
+  end
+end

data/lib/steep/ast/types/var.rb

@@ -0,0 +1,57 @@
+module Steep
+  module AST
+    module Types
+      class Var
+        attr_reader :name
+        attr_reader :location
+
+        def initialize(name:, location: nil)
+          @name = name
+          @location = location
+        end
+
+        def ==(other)
+          other.is_a?(Var) &&
+            other.name == name
+        end
+
+        def hash
+          self.class.hash ^ name.hash
+        end
+
+        alias eql? ==
+
+        def self.fresh(name)
+          @mutex ||= Mutex.new
+
+          @mutex.synchronize do
+            @max ||= 0
+            @max += 1
+
+            new(name: :"#{name}(#{@max})")
+          end
+        end
+
+        def to_s
+          "'#{name}"
+        end
+
+        def subst(s)
+          if s.key?(name)
+            s[name]
+          else
+            self
+          end
+        end
+
+        def free_variables
+          Set.new([name])
+        end
+
+        def level
+          [0]
+        end
+      end
+    end
+  end
+end

data/lib/steep/ast/types/void.rb

@@ -0,0 +1,35 @@
+module Steep
+  module AST
+    module Types
+      class Void
+        attr_reader :location
+
+        def initialize(location: nil)
+          @location = location
+        end
+
+        def ==(other)
+          other.is_a?(Void)
+        end
+
+        def hash
+          self.class.hash
+        end
+
+        alias eql? ==
+
+        def subst(s)
+          self
+        end
+
+        def to_s
+          "void"
+        end
+
+        def free_variables
+          Set.new
+        end
+      end
+    end
+  end
+end

data/lib/steep/cli.rb

@@ -16,7 +16,7 @@ module Steep
     end
 
     def self.available_commands
-      [:check]
+      [:check, :validate, :annotations, :scaffold]
     end
 
     def setup_global_options
@@ -75,5 +75,32 @@ module Steep
         check.fallback_any_is_error = fallback_any_is_error
       end.run
     end
+
+    def process_validate
+      verbose = false
+
+      OptionParser.new do |opts|
+        opts.on("--verbose") { verbose = true }
+      end.parse!(argv)
+
+      signature_dirs = argv.map {|path| Pathname(path) }
+      if signature_dirs.empty?
+        signature_dirs << Pathname(".")
+      end
+
+      Drivers::Validate.new(signature_dirs: signature_dirs, stdout: stdout, stderr: stderr).tap do |validate|
+        validate.verbose = verbose
+      end.run
+    end
+
+    def process_annotations
+      source_paths = argv.map {|file| Pathname(file) }
+      Drivers::Annotations.new(source_paths: source_paths, stdout: stdout, stderr: stderr).run
+    end
+
+    def process_scaffold
+      source_paths = argv.map {|file| Pathname(file) }
+      Drivers::Scaffold.new(source_paths: source_paths, stdout: stdout, stderr: stderr).run
+    end
   end
 end

data/lib/steep/drivers/annotations.rb

@@ -0,0 +1,32 @@
+module Steep
+  module Drivers
+    class Annotations
+      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|
+          source.each_annotation.sort_by {|node, _| [node.loc.expression.begin_pos, node.loc.expression.end_pos] }.each do |node, annotations|
+            loc = node.loc
+            stdout.puts "#{source.path}:#{loc.line}:#{loc.column}:#{node.type}:\t#{node.loc.expression.source.lines.first}"
+            annotations.each do |annotation|
+              stdout.puts "  #{annotation.location.source}"
+            end
+          end
+        end
+      end
+    end
+  end
+end