steep 1.7.0.dev.4 → 1.7.0

data/sig/steep/type_inference/type_env.rbs

@@ -1,160 +0,0 @@
-module Steep
-  module TypeInference
-    # TypeEnv is the one-stop class to manage type of variables.
-    #
-    # ### Local variables primitive operations
-    #
-    # * Assigning to a local variable
-    # * Adding local variable type enforcement
-    # * Refine local variable types
-    # * Resetting refinements
-    #
-    # ### Pure calls primitive operations
-    #
-    # * Adding pure calls
-    # * Removing pure calls
-    # * Refine pure call types
-    # * Resetting pure call refinements
-    #
-    # ### Branch operations
-    #
-    # * Start branching with refinements
-    # * Merge branches
-    #
-    #
-    class TypeEnv
-      include NodeHelper
-
-      type local_variable_entry = [AST::Types::t, AST::Types::t?]
-
-      attr_reader local_variable_types: Hash[Symbol, local_variable_entry]
-
-      attr_reader pure_method_calls: Hash[Parser::AST::Node, [MethodCall::Typed, AST::Types::t?]]
-
-      attr_reader instance_variable_types: Hash[Symbol, AST::Types::t]
-
-      attr_reader global_types: Hash[Symbol, AST::Types::t]
-
-      attr_reader constant_types: Hash[RBS::TypeName, AST::Types::t]
-
-      attr_reader constant_env: ConstantEnv
-
-      @pure_node_descendants: Hash[Parser::AST::Node, Set[Parser::AST::Node]]
-
-      def initialize: (
-          ConstantEnv,
-          ?local_variable_types: Hash[Symbol, local_variable_entry],
-          ?instance_variable_types: Hash[Symbol, AST::Types::t],
-          ?global_types: Hash[Symbol, AST::Types::t],
-          ?constant_types: Hash[RBS::TypeName, AST::Types::t],
-          ?pure_method_calls: Hash[Parser::AST::Node, [MethodCall::Typed, AST::Types::t?]]
-        ) -> void
-
-      def update: (
-          ?local_variable_types: Hash[Symbol, local_variable_entry],
-          ?instance_variable_types: Hash[Symbol, AST::Types::t],
-          ?global_types: Hash[Symbol, AST::Types::t],
-          ?constant_types: Hash[RBS::TypeName, AST::Types::t],
-          ?pure_method_calls: Hash[Parser::AST::Node, [MethodCall::Typed, AST::Types::t?]]
-        ) -> TypeEnv
-
-      def merge: (
-          ?local_variable_types: Hash[Symbol, local_variable_entry],
-          ?instance_variable_types: Hash[Symbol, AST::Types::t],
-          ?global_types: Hash[Symbol, AST::Types::t],
-          ?constant_types: Hash[RBS::TypeName, AST::Types::t],
-          ?pure_method_calls: Hash[Parser::AST::Node, [MethodCall::Typed, AST::Types::t?]]
-        ) -> TypeEnv
-
-      # Returns type of `name`.
-      #
-      def []: (Symbol name) -> AST::Types::t?
-            | (Parser::AST::Node node) -> AST::Types::t?
-
-      # Tells the environment that local variables are updated.
-      # Keeps their enforced types and invalidates related nodes.
-      #
-      def assign_local_variables: (Hash[Symbol, AST::Types::t]) -> TypeEnv
-
-      # Tells the environment that the local variable is updated with it's enforced type.
-      #
-      # Invalidates related nodes.
-      #
-      def assign_local_variable: (Symbol name, AST::Types::t type, AST::Types::t? enforced_type) -> TypeEnv
-
-      # Refines types of local variables and pure calls.
-      #
-      # * Receives types of updated local variables and pure calls.
-      # * The local variable types will be
-      #
-      def refine_types: (?local_variable_types: Hash[Symbol, AST::Types::t], ?pure_call_types: Hash[Parser::AST::Node, AST::Types::t]) -> TypeEnv
-
-      def enforced_type: (Symbol name) -> AST::Types::t?
-
-      # Returns type of constant of `const_name`, or `const_name` under `mod_name`.
-      #
-      # Returns `nil` if no such constant found.
-      #
-      def constant: (Symbol const_name, bool toplevel) -> ConstantEnv::constant_tuple?
-                  | (RBS::TypeName mod_name, Symbol const_name) -> ConstantEnv::constant_tuple?
-
-      def annotated_constant: (RBS::TypeName) -> AST::Types::t?
-
-      # _Pin_ the local variables if array is given.
-      # When `nil` is given, all local variables are _pinned_.
-      #
-      def pin_local_variables: (Array[Symbol]? names) -> Hash[Symbol, local_variable_entry]
-
-      # _Unpin_ the local variables if array is given.
-      # When `nil` is given, all local variables are _unpinned_.
-      #
-      def unpin_local_variables: (Array[Symbol]? names) -> TypeEnv
-
-      def to_s: () -> String
-
-      # Apply the substitution to the type of local variables.
-      #
-      def subst: (Interface::Substitution) -> TypeEnv
-
-      # Returns a `TypeEnv` such that:
-      #
-      # * All of the given environments are result of the type checking of branches from `self`,
-      # * All of the branches meet at one point, with the returned `TypeEnv`
-      #
-      # See the example below:
-      #
-      # ```ruby
-      # if foo()         # The original environment `self` is for after the evaluation of `foo()`
-      #   a = bar()      # One environment `env1` can be given from after the evaluation of `bar()`
-      # else
-      #   b = baz()      # Another environment `env2` is from after the evaluation of `baz`
-      # end
-      #
-      # ???              # How is the environment for here is `self.merge(env1, env2)`
-      #                  # The environment has both optional types of `a` and `b`
-      # ```
-      #
-      def join: (*TypeEnv) -> TypeEnv
-
-      def add_pure_call: (Parser::AST::Node, MethodCall::Typed, AST::Types::t?) -> TypeEnv
-
-      def replace_pure_call_type: (Parser::AST::Node, AST::Types::t) -> TypeEnv
-
-      def invalidate_pure_node: (Parser::AST::Node) -> TypeEnv
-
-      private
-
-      def pure_node_invalidation: (Enumerable[Parser::AST::Node] invalidated_nodes) -> Hash[Parser::AST::Node, [MethodCall::Typed, AST::Types::t?]]
-
-      def invalidated_pure_nodes: (Parser::AST::Node) -> Set[Parser::AST::Node]
-
-      def local_variable_name?: (Symbol) -> bool
-
-      def local_variable_name!: (Symbol) -> void
-
-      def instance_variable_name?: (Symbol) -> bool
-
-      def global_name?: (Symbol) -> bool
-    end
-  end
-end

data/sig/steep/type_inference/type_env_builder.rbs

@@ -1,81 +0,0 @@
-module Steep
-  module TypeInference
-    class TypeEnvBuilder
-      module Command
-        interface _Base
-          def call: (TypeEnv) -> TypeEnv
-        end
-
-        class RBSBase
-          attr_reader environment: RBS::Environment
-
-          attr_reader factory: AST::Types::Factory
-
-          def initialize: (AST::Types::Factory) -> void
-        end
-
-        class AnnotationsBase
-          attr_reader annotations: AST::Annotation::Collection
-
-          def initialize: (AST::Annotation::Collection) -> void
-        end
-
-        # Insert local variable annotations.
-        #
-        # * When _merge mode_ is on, adds and overwrite local variables.
-        # * When _merge mode_ is off, it wipes all existing local variables and adds from annotations.
-        #
-        class ImportLocalVariableAnnotations < AnnotationsBase
-          include _Base
-
-          attr_reader on_duplicate: (^(Symbol, AST::Types::t, AST::Types::t) -> void)?
-
-          @merge: bool
-
-          # Set _merge mode_ `on`.
-          def merge!: (?bool) -> self
-
-          def on_duplicate!: () { (Symbol name, AST::Types::t original, AST::Types::t annotation) -> void } -> self
-        end
-
-        # Insert global variable types into type environment from `RBS::Environment`.
-        #
-        class ImportGlobalDeclarations < RBSBase
-          def merge!: (?bool) -> self
-
-          @merge: bool
-
-          include _Base
-        end
-
-        class ImportInstanceVariableAnnotations < AnnotationsBase
-          def merge!: (?bool) -> self
-                    
-          include _Base
-
-          @merge: bool
-        end
-
-        class ImportInstanceVariableDefinition
-          attr_reader definition: RBS::Definition?
-
-          attr_reader factory: AST::Types::Factory
-
-          def initialize: (RBS::Definition?, AST::Types::Factory) -> void
-
-          include _Base
-        end
-
-        class ImportConstantAnnotations < AnnotationsBase
-          include _Base
-        end
-      end
-
-      attr_reader commands: Array[Command::_Base]
-
-      def initialize: (*Command::_Base?) -> void
-
-      def build: (TypeEnv) -> TypeEnv
-    end
-  end
-end

data/sig/steep/typing.rbs

@@ -1,75 +0,0 @@
-use Steep::TypeInference::Context, Steep::TypeInference::ContextArray, Steep::TypeInference::MethodCall
-
-module Steep
-  class Typing
-    class UnknownNodeError < StandardError
-      attr_reader op: Symbol
-
-      attr_reader node: Parser::AST::Node
-
-      def initialize: (Symbol op, node: Parser::AST::Node) -> void
-    end
-
-    attr_reader source: Source
-
-    attr_reader errors: Array[Diagnostic::Ruby::Base]
-
-    attr_reader typing: Hash[Parser::AST::Node, AST::Types::t]
-
-    attr_reader parent: Typing?
-
-    attr_reader parent_last_update: Integer?
-
-    attr_reader last_update: Integer
-
-    attr_reader should_update: bool
-
-    attr_reader contexts: ContextArray
-
-    attr_reader root_context: Context
-
-    attr_reader method_calls: Hash[Parser::AST::Node, MethodCall::t]
-
-    attr_reader source_index: Index::SourceIndex
-
-    def initialize: (source: Source, root_context: Context, ?parent: Typing?, ?parent_last_update: Integer?, ?contexts: ContextArray?, ?source_index: Index::SourceIndex?) -> void
-
-    def add_error: (Diagnostic::Ruby::Base error) -> void
-
-    def add_typing: (Parser::AST::Node node, AST::Types::t `type`, top) -> void
-
-    def add_call: (Parser::AST::Node node, MethodCall::t call) -> void
-
-    def add_context: (Range[Integer] range, context: Context) -> void
-
-    def has_type?: (Parser::AST::Node node) -> bool
-
-    def type_of: (node: Parser::AST::Node) -> AST::Types::t
-
-    def call_of: (node: Parser::AST::Node) -> TypeInference::MethodCall::t
-
-    def add_context_for_node: (Parser::AST::Node node, context: Context) -> void
-
-    def block_range: (Parser::AST::Node node) -> Range[Integer]
-
-    def add_context_for_body: (Parser::AST::Node node, context: Context) -> void
-
-    def context_at: (line: Integer, column: Integer) -> Context
-
-    def dump: (untyped io) -> untyped
-
-    def self.summary: (untyped node) -> ::String
-
-    def new_child: [A] (Range[Integer] range) { (Typing) -> A } -> A
-                 | (Range[Integer]) -> Typing
-
-    def each_typing: () { ([Parser::AST::Node, AST::Types::t]) -> void } -> void
-
-    # Push the current changes to the `#parent` typing
-    #
-    # * Raises an error if `#parent` is `nil`
-    # * Raises an error if `#parent` is changed since `#new_child` call that instantiated `self`
-    #
-    def save!: () -> void
-  end
-end

data/sig/steep.rbs

@@ -1,45 +0,0 @@
-module Steep
-  VERSION: String
-
-  # `ui_logger` is a logger for user interaction messages
-  #
-  # The *main* process has the logger.
-  # The *worker* processes disables the logging through this.
-  #
-  def self.ui_logger: () -> (Logger & ActiveSupport::TaggedLogging)
-
-  def self.logger: () -> (Logger & ActiveSupport::TaggedLogging)
-
-  def self.new_logger: (IO output, Integer? prev_level) -> (Logger & ActiveSupport::TaggedLogging)
-
-  attr_accessor self.log_output: IO
-
-  def self.measure: [A] (String message, ?level: ::Symbol, ?threshold: Float) { () -> A } -> A
-
-  def self.log_error: (Exception exn, ?message: ::String) -> void
-
-  self.@logger: (Logger & ActiveSupport::TaggedLogging)?
-
-  self.@ui_logger: (Logger & ActiveSupport::TaggedLogging)?
-
-  class Sampler
-    type sample = [String, Float]
-    @samples: Array[sample]
-
-    def initialize: () -> void
-
-    def sample: [A] (String message) { () -> A } -> A
-
-    def count: () -> Integer
-
-    def total: () -> Float
-
-    def slowests: (Integer num) -> Array[sample]
-
-    def average: () -> Float
-
-    def percentile: (Integer p) -> Float
-  end
-
-  def self.measure2: [A] (String message, ?level: ::Symbol) { (Sampler) -> A } -> A
-end