steep 0.1.0.pre

data/lib/steep/type_name.rb

@@ -0,0 +1,37 @@
+module Steep
+  module TypeName
+    class Base
+      attr_reader :name
+
+      def initialize(name:)
+        @name = name
+      end
+
+      def ==(other)
+        other.is_a?(self.class) && other.name == name
+      end
+
+      def hash
+        name.hash
+      end
+
+      def eql?(other)
+        self == other
+      end
+
+      def to_s
+        name.to_s
+      end
+    end
+
+    class Interface < Base; end
+
+    class Module < Base
+      def to_s
+        "#{name}.module"
+      end
+    end
+
+    class Instance < Base; end
+  end
+end

data/lib/steep/types.rb

@@ -0,0 +1,4 @@
+module Steep
+  module Types
+  end
+end

data/lib/steep/types/any.rb

@@ -0,0 +1,31 @@
+module Steep
+  module Types
+    class Any
+      # @implements Steep__Types__Any
+
+      def ==(other)
+        other.is_a?(Any)
+      end
+
+      def hash
+        self.class.hash
+      end
+
+      def eql?(other)
+        other == self
+      end
+
+      def closed?
+        true
+      end
+
+      def substitute(klass:, instance:, params:)
+        self
+      end
+
+      def to_s
+        "any"
+      end
+    end
+  end
+end

data/lib/steep/types/class.rb

@@ -0,0 +1,27 @@
+module Steep
+  module Types
+    class Class
+      # @implements Steep__Types__Class
+
+      def ==(other)
+        other.is_a?(Class)
+      end
+
+      def hash
+        self.class.hash
+      end
+
+      def eql?(other)
+        self == other
+      end
+
+      def closed?
+        false
+      end
+
+      def substitute(klass:, instance:, params:)
+        klass
+      end
+    end
+  end
+end

data/lib/steep/types/instance.rb

@@ -0,0 +1,27 @@
+module Steep
+  module Types
+    class Instance
+      # @implements Steep__Types__Instance
+
+      def ==(other)
+        other.is_a?(Instance)
+      end
+
+      def eql?(other)
+        self == other
+      end
+
+      def hash
+        self.class.hash
+      end
+
+      def closed?
+        false
+      end
+
+      def substitute(klass:, instance:, params:)
+        instance
+      end
+    end
+  end
+end

data/lib/steep/types/merge.rb

@@ -0,0 +1,32 @@
+module Steep
+  module Types
+    class Merge
+      # @implements Steep__Types__Merge
+
+      # @dynamic types
+      attr_reader :types
+
+      def initialize(types:)
+        @types = types
+      end
+
+      def ==(other)
+        # @type var other_: Steep__Types__Merge
+        other_ = other
+        other_.is_a?(self.class) && other_.types == types
+      end
+
+      def hash
+        self.class.hash ^ types.hash
+      end
+
+      def eql?(other)
+        other == self
+      end
+
+      def to_s
+        types.join(" + ")
+      end
+    end
+  end
+end

data/lib/steep/types/name.rb

@@ -0,0 +1,57 @@
+module Steep
+  module Types
+    class Name
+      # @implements Steep__Types__Name
+      # @type const TypeName::Interface: Steep__TypeName.class
+      # @type const TypeName::Module: Steep__TypeName.class
+      # @type const TypeName::Instance: Steep__TypeName.class
+
+      # @dynamic name
+      attr_reader :name
+
+      # @dynamic params
+      attr_reader :params
+
+      def initialize(name:, params:)
+        @name = name
+        @params = params
+      end
+
+      def self.interface(name:, params: [])
+        self.new(name: TypeName::Interface.new(name: name), params: params)
+      end
+
+      def self.module(name:, params: [])
+        self.new(name: TypeName::Module.new(name: name), params: params)
+      end
+
+      def self.instance(name:, params: [])
+        self.new(name: TypeName::Instance.new(name: name), params: params)
+      end
+
+      def ==(other)
+        other.is_a?(Name) && name == other.name && other.params == params
+      end
+
+      def hash
+        name.hash ^ params.hash
+      end
+
+      def eql?(other)
+        other == self
+      end
+
+      def closed?
+        true
+      end
+
+      def substitute(klass:, instance:, params:)
+        self.class.new(name: name, params: self.params.map {|t| t.substitute(klass: klass, instance: instance, params: params) })
+      end
+
+      def to_s
+        "#{name}" + (params.empty? ? "" : "<#{params.map {|x| x.to_s }.join(", ")}>")
+      end
+    end
+  end
+end

data/lib/steep/types/union.rb

@@ -0,0 +1,42 @@
+module Steep
+  module Types
+    class Union
+      # @implements Steep__Types__Union
+      # @type const Union: Steep__Types__Union.module
+
+      # @dynamic types
+      attr_reader :types
+
+      def initialize(types:)
+        @types = types
+      end
+
+      def ==(other_)
+        other = other_
+
+        # @type var other: Steep__Types__Union
+        other.is_a?(Union) && other.types.sort_by {|x| x.__id__ } == types.sort_by {|x| x.__id__ }
+      end
+
+      def hash
+        types.hash
+      end
+
+      def eql?(other)
+        self == other
+      end
+
+      def closed?
+        types.all? {|x| x.closed? }
+      end
+
+      def substitute(klass:, instance:, params:)
+        self.class.new(types: types.map {|t| t.substitute(klass: klass, instance: instance, params: params) })
+      end
+
+      def to_s
+        types.join(" | ")
+      end
+    end
+  end
+end

data/lib/steep/types/var.rb

@@ -0,0 +1,38 @@
+module Steep
+  module Types
+    class Var
+      # @implements Steep__Types__Var
+
+      # @dynamic name
+      attr_reader :name
+
+      def initialize(name:)
+        @name = name
+      end
+
+      def ==(other)
+        other.is_a?(Var) && other.name == name
+      end
+
+      def hash
+        name.hash
+      end
+
+      def eql?(other)
+        self == other
+      end
+
+      def closed?
+        true
+      end
+
+      def substitute(klass:, instance:, params:)
+        params[name] || self
+      end
+
+      def to_s
+        "'#{name}"
+      end
+    end
+  end
+end

data/lib/steep/typing.rb

@@ -0,0 +1,70 @@
+module Steep
+  class Typing
+    attr_reader :errors
+    attr_reader :typing
+    attr_reader :nodes
+    attr_reader :var_typing
+
+    def initialize
+      @errors = []
+      @nodes = {}
+      @var_typing = {}
+      @typing = {}
+    end
+
+    def add_error(error)
+      errors << error
+    end
+
+    def add_typing(node, type)
+      typing[node.__id__] = type
+      nodes[node.__id__] = node
+
+      type
+    end
+
+    def add_var_type(variable, type)
+      if var_typing.key?(variable)
+        unless var_typing[variable] == type
+          raise "Unexpected variable typing: existing=#{var_typing[variable]}, new=#{type}"
+        end
+      end
+
+      var_typing[variable] = type
+    end
+
+    def type_of(node:)
+      typing[node.__id__] or raise "Unknown node for typing: #{node.inspect}"
+    end
+
+    def type_of_variable(name: nil, label: nil)
+      var_typing.each do |var, type|
+        if (!name || var.name == name) && (!label || var.label == label)
+          return type
+        end
+      end
+
+      raise "Unknown variable for typing: #{name}@#{label}"
+    end
+
+    def dump(io)
+      io.puts "Typing: "
+      nodes.each_value do |node|
+        io.puts "  #{Typing.summary(node)} => #{type_of(node: node).inspect}"
+      end
+
+      io.puts "Errors: "
+      errors.each do |error|
+        io.puts "  #{Typing.summary(error.node)} => #{error.inspect}"
+      end
+    end
+
+    def self.summary(node)
+      src = node.loc.expression.source.split(/\n/).first
+      line = node.loc.first_line
+      col = node.loc.column
+
+      "#{line}:#{col}:#{src}"
+    end
+  end
+end

data/lib/steep/version.rb

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

data/manual/annotations.md

@@ -0,0 +1,144 @@
+# Annotations
+
+## Core Annotations
+
+### Variable type
+
+Variable type annotation tells type of local variable.
+
+#### Example
+
+```
+# @type var x: String
+# @type var klass: Class
+```
+
+#### Syntax
+
+* `@type` `var` *x* `:` *type*
+
+### Self type
+
+Self type annotation tells type of `self`.
+
+#### Example
+
+```
+# @type self: Object
+```
+
+#### Syntax
+
+* `@type` `self` `:` *type*
+
+### Instance variable type
+
+Instance variable type annotation tells type of instance variable.
+This annotation applies to instance variable of current context.
+If it's written in `module` declaration, it applies to instance variable of the module, not its instance.
+
+#### Example
+
+```
+# @type ivar @owner: Person
+```
+
+#### Syntax
+
+* `@type` `ivar` *ivar* `:` *type*
+
+### Global variable type
+
+Global variable type annotation tells type of global variable.
+
+#### Example
+
+```
+# @type gvar $LOAD_PATH: Array<String>
+```
+
+#### Syntax
+
+* `@type` `gvar` *gvar* `:` *type*
+
+### Constant type
+
+Constant type annotation tells type of constant.
+Note that constant resolution is done syntactically.
+Annotation on `File::Append` does not apply to `::File::Append`.
+
+#### Example
+
+```
+# @type const File::Append : Integer
+```
+
+#### Syntax
+
+* `@type` `const` *const* `:` *type*
+
+### Method type annotation
+
+Method type annotation tells type of method being implemented in current scope.
+
+This annotation is used to tell types of method parameters and its body.
+Union method type cannot be written.
+
+#### Example
+
+```
+# @type method foo: (String) -> any
+```
+
+#### Syntax
+
+* `@type` `method` *method* `:` *single method type*
+
+## Module Annotations
+
+Module annotations is about defining modules and classes in Ruby.
+This kind of annotations should be written in module context.
+
+### Instance type annotation
+
+Instance type annotation tells type of instance of class or module which is being defined.
+
+#### Example
+
+```
+# @type instance: Foo
+```
+
+#### Syntax
+
+* `@type` `instance` `:` *type*
+
+### Module type annotation
+
+Module type annotation tells type of module of class or module which is being defined.
+
+#### Example
+
+```
+# @type module: Foo.class
+```
+
+#### Syntax
+
+* `@type` `module` `:` *type*
+
+### Instance/module ivar type annotation
+
+This annotation tells instance variable of instance.
+
+#### Example
+
+```
+# @type instance ivar @x: String
+# @type module ivar @klass: String.class
+```
+
+#### Syntax
+
+* `@type` `instance` `ivar` *ivar* `:` *type*
+* `@type` `module` `ivar` *ivar* `:` *type*