steep 0.13.0 → 0.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0e95857ced793435c07c948b2a51ac914c52816811ae8e5d18337bcf946eb33d
-  data.tar.gz: 9038e63999222be3e0b7172aa423056ef7792b905e1d277271fa795b6ca06889
+  metadata.gz: 86924db409406024edb29a087196304bacba8730dfa3c986c604fbe8b6b9a6fd
+  data.tar.gz: d688f6b2f58343da51328f13bc26da7e4e54de7f1dd9393f0cd98d48c5ea8420
 SHA512:
-  metadata.gz: 2747b3e5f3303ae48a91e76b2256cd1e402e7022caa714083267da0820f1bce2d81188586e551a10158d4c6716ab7a8db8562aa84b31c98731872b08d05048c9
-  data.tar.gz: 9d5bd44685d8228ee304bdaf94ae52e5eef2a2871580e7190ef941ea510406eab28bdb3aa6849fd9234649da10cd9344e2c38ba309a11a73cca70c6ed7e946e3
+  metadata.gz: a70b109afc79267f2a47425dcc8b93f05074fbffa1e410fa62824b5a94320f18a9274182ad2fbaa4083867dd0bab9e4e8796fc8b472edd2328d2b332e76f9f66
+  data.tar.gz: 6b4dc08b74b0f042b325180f1b358862d510fefe06a9e07f06380bbf7e86f47e3547d365d0cc94a278c80946befec64689a5c56e87a3e820db767103727e69f7

data/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 ## master
 
+## 0.14.0 (2020-02-24)
+
+* Implementat LSP _completion_. ([#119](https://github.com/soutaro/steep/pull/119))
+* Update ruby-signature. ([#120](https://github.com/soutaro/steep/pull/120))
+* Rescue errors during `langserver`. ([#121](https://github.com/soutaro/steep/pull/121))
+* Pass hint when type checking `return`. ([#122](https://github.com/soutaro/steep/pull/122))
+* Remove trailing spaces from Steepfile. ([#118](https://github.com/soutaro/steep/pull/118))
+
 ## 0.13.0 (2020-02-16)
 
 * Improve LSP _hover_ support. ([#117](https://github.com/soutaro/steep/pull/117))

data/lib/steep.rb

@@ -74,6 +74,7 @@ require "steep/project/target"
 require "steep/project/dsl"
 require "steep/project/file_loader"
 require "steep/project/hover_content"
+require "steep/project/completion_provider"
 require "steep/drivers/utils/driver_helper"
 require "steep/drivers/check"
 require "steep/drivers/validate"
@@ -114,4 +115,19 @@ module Steep
 
   @logger = nil
   self.log_output = STDERR
+
+  def self.measure(message)
+    start = Time.now
+    yield.tap do
+      time = Time.now - start
+      self.logger.info "#{message} took #{time} seconds"
+    end
+  end
+
+  def self.log_error(exn, message: "Unexpected error: #{exn.inspect}")
+    Steep.logger.error message
+    exn.backtrace.each do |loc|
+      Steep.logger.warn "  #{loc}"
+    end
+  end
 end

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

@@ -187,47 +187,82 @@ module Steep
         end
 
         def method_type(method_type, self_type:)
-          case method_type
-          when Ruby::Signature::MethodType
-            fvs = self_type.free_variables()
-
-            type_params = []
-            alpha_vars = []
-            alpha_types = []
-
-            method_type.type_params.map do |name|
-              if fvs.include?(name)
-                type = Types::Var.fresh(name)
-                alpha_vars << name
-                alpha_types << type
-                type_params << type.name
-              else
-                type_params << name
-              end
+          fvs = self_type.free_variables()
+
+          type_params = []
+          alpha_vars = []
+          alpha_types = []
+
+          method_type.type_params.map do |name|
+            if fvs.include?(name)
+              type = Types::Var.fresh(name)
+              alpha_vars << name
+              alpha_types << type
+              type_params << type.name
+            else
+              type_params << name
             end
-            subst = Interface::Substitution.build(alpha_vars, alpha_types)
-
-            type = Interface::MethodType.new(
-              type_params: type_params,
-              return_type: type(method_type.type.return_type).subst(subst),
-              params: params(method_type.type).subst(subst),
-              location: nil,
-              block: method_type.block&.yield_self do |block|
-                Interface::Block.new(
-                  optional: !block.required,
-                  type: Proc.new(params: params(block.type).subst(subst),
-                                 return_type: type(block.type.return_type).subst(subst), location: nil)
-                )
-              end
-            )
+          end
+          subst = Interface::Substitution.build(alpha_vars, alpha_types)
+
+          type = Interface::MethodType.new(
+            type_params: type_params,
+            return_type: type(method_type.type.return_type).subst(subst),
+            params: params(method_type.type).subst(subst),
+            location: nil,
+            block: method_type.block&.yield_self do |block|
+              Interface::Block.new(
+                optional: !block.required,
+                type: Proc.new(params: params(block.type).subst(subst),
+                               return_type: type(block.type.return_type).subst(subst), location: nil)
+              )
+            end
+          )
+
+          if block_given?
+            yield type
+          else
+            type
+          end
+        end
+
+        def method_type_1(method_type, self_type:)
+          fvs = self_type.free_variables()
 
-            if block_given?
-              yield type
+          type_params = []
+          alpha_vars = []
+          alpha_types = []
+
+          method_type.type_params.map do |name|
+            if fvs.include?(name)
+              type = Ruby::Signature::Types::Variable.new(name: name, location: nil),
+              alpha_vars << name
+              alpha_types << type
+              type_params << type.name
             else
-              type
+              type_params << name
             end
-          when :any
-            :any
+          end
+          subst = Interface::Substitution.build(alpha_vars, alpha_types)
+
+          type = Ruby::Signature::MethodType.new(
+            type_params: type_params,
+            type: function_1(method_type.params.subst(subst), method_type.return_type.subst(subst)),
+            block: method_type.block&.yield_self do |block|
+              block_type = block.type.subst(subst)
+
+              Ruby::Signature::MethodType::Block.new(
+                type: function_1(block_type.params, block_type.return_type),
+                required: !block.optional
+              )
+            end,
+            location: nil
+          )
+
+          if block_given?
+            yield type
+          else
+            type
           end
         end
 

data/lib/steep/drivers/init.rb

@@ -10,21 +10,21 @@ module Steep
       TEMPLATE = <<~EOF
       # target :lib do
       #   signature "sig"
-      # 
+      #
       #   check "lib"                       # Directory name
       #   check "Gemfile"                   # File name
       #   check "app/models/**/*.rb"        # Glob
-      #   # ignore "lib/templates/*.rb"        
-      #   
+      #   # ignore "lib/templates/*.rb"
+      #
       #   # library "pathname", "set"       # Standard libraries
       #   # library "strong_json"           # Gems
       # end
 
       # target :spec do
       #   signature "sig", "sig-private"
-      # 
+      #
       #   check "spec"
-      # 
+      #
       #   # library "pathname", "set"       # Standard libraries
       #   # library "rspec"
       # end

data/lib/steep/drivers/langserver.rb

@@ -84,10 +84,55 @@ module Steep
                   change: LanguageServer::Protocol::Constant::TextDocumentSyncKind::FULL
                 ),
                 hover_provider: true,
+                completion_provider: LanguageServer::Protocol::Interface::CompletionOptions.new(
+                  trigger_characters: [".", "@"],
                 )
+              )
             )
 
             enqueue_type_check nil
+
+          when :"textDocument/completion"
+            Steep.logger.error request.inspect
+            begin
+              params = request[:params]
+              uri = URI.parse(params[:textDocument][:uri])
+              path = project.relative_path(Pathname(uri.path))
+              target = project.targets.find {|target| target.source_file?(path) }
+              case (status = target&.status)
+              when Project::Target::TypeCheckStatus
+                subtyping = status.subtyping
+                source = target.source_files[path]
+
+                line, column = params[:position].yield_self {|hash| [hash[:line]+1, hash[:character]] }
+                trigger = params[:context][:triggerCharacter]
+
+                Steep.logger.error "line: #{line}, column: #{column}, trigger: #{trigger}"
+
+                provider = Project::CompletionProvider.new(source_text: source.content, path: path, subtyping: subtyping)
+                items = begin
+                          provider.run(line: line, column: column)
+                        rescue Parser::SyntaxError
+                          []
+                        end
+
+                completion_items = items.map do |item|
+                  format_completion_item(item)
+                end
+
+                Steep.logger.debug "items = #{completion_items.inspect}"
+
+                yield id, LanguageServer::Protocol::Interface::CompletionList.new(
+                  is_incomplete: false,
+                  items: completion_items
+                )
+              end
+
+            rescue Typing::UnknownNodeError => exn
+              Steep.log_error exn, message: "Failed to compute completion: #{exn.inspect}"
+              yield id, nil
+            end
+
           when :"textDocument/didChange"
             uri = URI.parse(request[:params][:textDocument][:uri])
             path = project.relative_path(Pathname(uri.path))
@@ -151,7 +196,11 @@ module Steep
         @type_check_thread = Thread.start do
           while request = type_check_queue.deq
             if @latest_update_version == nil || @latest_update_version == request.version
-              run_type_check()
+              begin
+                run_type_check()
+              rescue => exn
+                Steep.log_error exn
+              end
             end
           end
         end
@@ -185,13 +234,11 @@ module Steep
                                   source.errors.map {|error| diagnostic_for_type_error(error) }
                                 when Project::SourceFile::AnnotationSyntaxErrorStatus
                                   [diagnostics_raw(source.status.error.message, source.status.location)]
-                                when Project::SourceFile::ParseErrorStatus
-                                  []
-                                when Project::SourceFile::TypeCheckErrorStatus
-                                  []
                                 end
 
-                  report_diagnostics source.path, diagnostics
+                  if diagnostics
+                    report_diagnostics source.path, diagnostics
+                  end
                 end
               when Project::Target::SignatureSyntaxErrorStatus
                 Steep.logger.info { "Signature syntax error" }
@@ -280,6 +327,9 @@ module Steep
             range: range
           )
         end
+      rescue Typing::UnknownNodeError => exn
+        Steep.log_error exn, message: "Failed to compute hover: #{exn.inspect}"
+        nil
       end
 
       def format_hover(content)
@@ -331,6 +381,126 @@ HOVER
           "`#{content.type}`"
         end
       end
+
+      def format_completion_item(item)
+        range = LanguageServer::Protocol::Interface::Range.new(
+          start: LanguageServer::Protocol::Interface::Position.new(
+            line: item.range.start.line-1,
+            character: item.range.start.column
+          ),
+          end: LanguageServer::Protocol::Interface::Position.new(
+            line: item.range.end.line-1,
+            character: item.range.end.column
+          )
+        )
+
+        case item
+        when Project::CompletionProvider::LocalVariableItem
+          LanguageServer::Protocol::Interface::CompletionItem.new(
+            label: item.identifier,
+            kind: LanguageServer::Protocol::Constant::CompletionItemKind::VARIABLE,
+            detail: "#{item.identifier}: #{item.type}",
+            text_edit: LanguageServer::Protocol::Interface::TextEdit.new(
+              range: range,
+              new_text: "#{item.identifier}"
+            )
+          )
+        when Project::CompletionProvider::MethodNameItem
+          label = "def #{item.identifier}: #{item.method_type}"
+          method_type_snippet = method_type_to_snippet(item.method_type)
+          LanguageServer::Protocol::Interface::CompletionItem.new(
+            label: label,
+            kind: LanguageServer::Protocol::Constant::CompletionItemKind::METHOD,
+            text_edit: LanguageServer::Protocol::Interface::TextEdit.new(
+              new_text: "#{item.identifier}#{method_type_snippet}",
+              range: range
+            ),
+            documentation: item.definition.comment&.string,
+            insert_text_format: LanguageServer::Protocol::Constant::InsertTextFormat::SNIPPET
+          )
+        when Project::CompletionProvider::InstanceVariableItem
+          label = "#{item.identifier}: #{item.type}"
+          LanguageServer::Protocol::Interface::CompletionItem.new(
+            label: label,
+            kind: LanguageServer::Protocol::Constant::CompletionItemKind::FIELD,
+            text_edit: LanguageServer::Protocol::Interface::TextEdit.new(
+              range: range,
+              new_text: item.identifier,
+            ),
+            insert_text_format: LanguageServer::Protocol::Constant::InsertTextFormat::SNIPPET
+          )
+        end
+      end
+
+      def method_type_to_snippet(method_type)
+        params = if method_type.type.each_param.count == 0
+                   ""
+                 else
+                   "(#{params_to_snippet(method_type.type)})"
+                 end
+
+
+        block = if method_type.block
+                  open, space, close = if method_type.block.type.return_type.is_a?(Ruby::Signature::Types::Bases::Void)
+                                  ["do", " ", "end"]
+                                else
+                                  ["{", "", "}"]
+                                end
+
+                    if method_type.block.type.each_param.count == 0
+                    " #{open} $0 #{close}"
+                  else
+                    " #{open}#{space}|#{params_to_snippet(method_type.block.type)}| $0 #{close}"
+                  end
+                else
+                  ""
+                end
+
+        "#{params}#{block}"
+      end
+
+      def params_to_snippet(fun)
+        params = []
+
+        index = 1
+
+        fun.required_positionals.each do |param|
+          if name = param.name
+            params << "${#{index}:#{param.type}}"
+          else
+            params << "${#{index}:#{param.type}}"
+          end
+
+          index += 1
+        end
+
+        if fun.rest_positionals
+          params << "${#{index}:*#{fun.rest_positionals.type}}"
+          index += 1
+        end
+
+        fun.trailing_positionals.each do |param|
+          if name = param.name
+            params << "${#{index}:#{param.type}}"
+          else
+            params << "${#{index}:#{param.type}}"
+          end
+
+          index += 1
+        end
+
+        fun.required_keywords.each do |keyword, param|
+          if name = param.name
+            params << "#{keyword}: ${#{index}:#{name}_}"
+          else
+            params << "#{keyword}: ${#{index}:#{param.type}_}"
+          end
+
+          index += 1
+        end
+
+        params.join(", ")
+      end
     end
   end
 end

data/lib/steep/project/completion_provider.rb

@@ -0,0 +1,302 @@
+module Steep
+  class Project
+    class CompletionProvider
+      Position = Struct.new(:line, :column, keyword_init: true) do
+        def -(size)
+          Position.new(line: line, column: column - size)
+        end
+      end
+      Range = Struct.new(:start, :end, keyword_init: true)
+
+      InstanceVariableItem = Struct.new(:identifier, :range, :type, keyword_init: true)
+      LocalVariableItem = Struct.new(:identifier, :range, :type, keyword_init: true)
+      MethodNameItem = Struct.new(:identifier, :range, :definition, :method_type, keyword_init: true)
+
+      attr_reader :source_text
+      attr_reader :path
+      attr_reader :subtyping
+      attr_reader :modified_text
+      attr_reader :source
+      attr_reader :typing
+
+      def initialize(source_text:, path:, subtyping:)
+        @source_text = source_text
+        @path = path
+        @subtyping = subtyping
+      end
+
+      def type_check!(text)
+        @modified_text = text
+
+        Steep.measure "parsing" do
+          @source = SourceFile.parse(text, path: path, factory: subtyping.factory)
+        end
+
+        Steep.measure "typechecking" do
+          @typing = SourceFile.type_check(source, subtyping: subtyping)
+        end
+      end
+
+      def run(line:, column:)
+        source_text = self.source_text.dup
+        index = index_for(source_text, line:line, column: column)
+        possible_trigger = source_text[index-1]
+
+        Steep.logger.debug "possible_trigger: #{possible_trigger.inspect}"
+
+        position = Position.new(line: line, column: column)
+
+        begin
+          Steep.measure "type_check!" do
+            type_check!(source_text)
+          end
+
+          Steep.measure "completion item collection" do
+            items_for_trigger(position: position)
+          end
+
+        rescue Parser::SyntaxError => exn
+          Steep.logger.error "recovering syntax error: #{exn.inspect}"
+          case possible_trigger
+          when "."
+            source_text[index-1] = " "
+            type_check!(source_text)
+            items_for_dot(position: position)
+          when "@"
+            source_text[index-1] = " "
+            type_check!(source_text)
+            items_for_atmark(position: position)
+          else
+            []
+          end
+        end
+      end
+
+      def range_from_loc(loc)
+        Range.new(
+          start: Position.new(line: loc.line, column: loc.column),
+          end: Position.new(line: loc.last_line, column: loc.last_line)
+        )
+      end
+
+      def at_end?(pos, of:)
+        of.last_line == pos.line && of.last_column == pos.column
+      end
+
+      def range_for(position, prefix: "")
+        if prefix.empty?
+          Range.new(start: position, end: position)
+        else
+          Range.new(start: position - prefix.size, end: position)
+        end
+      end
+
+      def items_for_trigger(position:)
+        node, *parents = source.find_nodes(line: position.line, column: position.column)
+        node ||= source.node
+
+        return [] unless node
+
+        items = []
+
+        case
+        when node.type == :send && node.children[0] == nil && at_end?(position, of: node.loc.selector)
+          # foo ←
+          context = typing.context_of(node: node)
+          prefix = node.children[1].to_s
+
+          method_items_for_receiver_type(context.self_type,
+                                         include_private: true,
+                                         prefix: prefix,
+                                         position: position,
+                                         items: items)
+          local_variable_items_for_context(context, position: position, prefix: prefix, items: items)
+
+        when node.type == :lvar && at_end?(position, of: node.loc)
+          # foo ← (lvar)
+          context = typing.context_of(node: node)
+          local_variable_items_for_context(context, position: position, prefix: node.children[0].name.to_s, items: items)
+
+        when node.type == :send && node.children[0] && at_end?(position, of: node.loc.selector)
+          # foo.ba ←
+          context = typing.context_of(node: node)
+          receiver_type = case (type = typing.type_of(node: node.children[0]))
+                          when AST::Types::Self
+                            context.self_type
+                          else
+                            type
+                          end
+          prefix = node.children[1].to_s
+
+          method_items_for_receiver_type(receiver_type,
+                                         include_private: false,
+                                         prefix: prefix,
+                                         position: position,
+                                         items: items)
+
+        when node.type == :const && node.children[0] == nil && at_end?(position, of: node.loc)
+          # Foo ← (const)
+          context = typing.context_of(node: node)
+          prefix = node.children[1].to_s
+
+          method_items_for_receiver_type(context.self_type,
+                                         include_private: false,
+                                         prefix: prefix,
+                                         position: position,
+                                         items: items)
+
+        when node.type == :send && at_end?(position, of: node.loc.dot)
+          # foo.← ba
+          context = typing.context_of(node: node)
+          receiver_type = case (type = typing.type_of(node: node.children[0]))
+                          when AST::Types::Self
+                            context.self_type
+                          else
+                            type
+                          end
+
+          method_items_for_receiver_type(receiver_type,
+                                         include_private: false,
+                                         prefix: "",
+                                         position: position,
+                                         items: items)
+
+        when node.type == :ivar && at_end?(position, of: node.loc)
+          # @fo ←
+          context = typing.context_of(node: node)
+          instance_variable_items_for_context(context, position: position, prefix: node.children[0].to_s, items: items)
+
+        else
+          context = typing.context_of(node: node)
+
+          method_items_for_receiver_type(context.self_type,
+                                         include_private: true,
+                                         prefix: "",
+                                         position: position,
+                                         items: items)
+          local_variable_items_for_context(context, position: position, prefix: "", items: items)
+          instance_variable_items_for_context(context, position: position, prefix: "", items: items)
+        end
+
+        items
+      end
+
+      def items_for_dot(position:)
+        # foo. ←
+        shift_pos = position-1
+        node, *parents = source.find_nodes(line: shift_pos.line, column: shift_pos.column)
+        node ||= source.node
+
+        return [] unless node
+
+        if at_end?(shift_pos, of: node.loc)
+          context = typing.context_of(node: node)
+          receiver_type = case (type = typing.type_of(node: node))
+                          when AST::Types::Self
+                            context.self_type
+                          else
+                            type
+                          end
+
+          items = []
+          method_items_for_receiver_type(receiver_type,
+                                         include_private: false,
+                                         prefix: "",
+                                         position: position,
+                                         items: items)
+          items
+        else
+          []
+        end
+      end
+
+      def items_for_atmark(position:)
+        # @ ←
+        shift_pos = position-1
+        node, *parents = source.find_nodes(line: shift_pos.line, column: shift_pos.column)
+        node ||= source.node
+
+        return [] unless node
+
+        context = typing.context_of(node: node)
+        items = []
+        instance_variable_items_for_context(context, prefix: "", position: position, items: items)
+        items
+      end
+
+      def method_items_for_receiver_type(type, include_private:, prefix:, position:, items:)
+        range = range_for(position, prefix: prefix)
+        definition = case type
+                     when AST::Types::Name::Instance
+                       type_name = subtyping.factory.type_name_1(type.name)
+                       subtyping.factory.definition_builder.build_instance(type_name)
+                     when AST::Types::Name::Class, AST::Types::Name::Module
+                       type_name = subtyping.factory.type_name_1(type.name)
+                       subtyping.factory.definition_builder.build_singleton(type_name)
+                     when AST::Types::Name::Interface
+                       type_name = subtyping.factory.type_name_1(type.name)
+                       interface = subtyping.factory.env.find_class(type_name)
+                       subtyping.factory.definition_builder.build_interface(type_name, interface)
+                     end
+
+        if definition
+          definition.methods.each do |name, method|
+            if include_private || method.public?
+              if name.to_s.start_with?(prefix)
+                if word_name?(name.to_s)
+                  method.method_types.each do |method_type|
+                    items << MethodNameItem.new(identifier: name,
+                                                range: range,
+                                                definition: method,
+                                                method_type: method_type)
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+
+      def word_name?(name)
+        name =~ /\w/
+      end
+
+      def local_variable_items_for_context(context, position:, prefix:, items:)
+        range = range_for(position, prefix: prefix)
+        context.type_env.lvar_types.each do |name, type|
+          if name.to_s.start_with?(prefix)
+            items << LocalVariableItem.new(identifier: name,
+                                           range: range,
+                                           type: type)
+          end
+        end
+      end
+
+      def instance_variable_items_for_context(context, position:, prefix:, items:)
+        range = range_for(position, prefix: prefix)
+        context.type_env.ivar_types.map do |name, type|
+          if name.to_s.start_with?(prefix)
+            items << InstanceVariableItem.new(identifier: name,
+                                              range: range,
+                                              type: type)
+          end
+        end
+      end
+
+      def index_for(string, line:, column:)
+        index = 0
+
+        string.each_line.with_index do |s, i|
+          if i+1 == line
+            index += column
+            break
+          else
+            index += s.size
+          end
+        end
+
+        index
+      end
+    end
+  end
+end