yoda-language-server 0.4.0

data/lib/yoda/parsing/scopes/module_definition.rb

@@ -0,0 +1,36 @@
+module Yoda
+  module Parsing
+    module Scopes
+      # Wrapper class for class node.
+      # @see https://github.com/whitequark/parser/blob/2.2/doc/AST_FORMAT.md#module
+      # ```
+      # (module (const nil :Foo) (nil))
+      # "module Foo; end"
+      #  ~~~~~~ keyword
+      #              ~~~ end
+      # ```
+      class ModuleDefinition < Base
+        def const_node
+          @const_node ||= NodeObjects::ConstNode.new(node.children[0])
+        end
+
+        def body_nodes
+          [body_node]
+        end
+
+        def body_node
+          node.children.last
+        end
+
+        def kind
+          :module
+        end
+
+        # @return [String]
+        def scope_name
+          const_node.to_s(parent.scope_name)
+        end
+      end
+    end
+  end
+end

data/lib/yoda/parsing/scopes/root.rb

@@ -0,0 +1,25 @@
+module Yoda
+  module Parsing
+    module Scopes
+      # Represents root namespace.
+      class Root < Base
+        def body_nodes
+          [node.children.last]
+        end
+
+        def body_node
+          body_nodes.first
+        end
+
+        def kind
+          :root
+        end
+
+        # @return [String]
+        def scope_name
+          'Object'
+        end
+      end
+    end
+  end
+end

data/lib/yoda/parsing/source_analyzer.rb

@@ -0,0 +1,59 @@
+module Yoda
+  module Parsing
+    # @deprecated
+    class SourceAnalyzer
+      include AstTraversable
+
+      # @param source   [String]
+      # @param location [Location]
+      # @return [SourceAnalyzer]
+      def self.from_source(source, location)
+        new(Parser.new.parse(source), location)
+      end
+
+      attr_reader :ast, :location
+
+      # @param ast      [::Parser::AST::Node]
+      # @param location [Location]
+      def initialize(ast, location)
+        @ast = ast
+        @location = location
+      end
+
+      # @return [Array<::Parser::AST::Node>]
+      def nodes_to_current_location_from_root
+        @nodes_to_current_location ||= calc_nodes_to_current_location(ast, location)
+      end
+
+      # @return [true, false]
+      def on_method?
+        !!current_method_node
+      end
+
+      # @return [::Parser::AST::Node]
+      def current_method_node
+        nodes_to_current_location_from_root.reverse.find { |node| [:def, :defs].include?(node.type) }
+      end
+
+      # @return [Array<::Parser::AST::Node>]
+      def current_namespace_nodes
+        nodes_to_current_location_from_root.find_all { |node| [:class, :module, :sclass].include?(node.type) }
+      end
+
+      # @return [Namespace]
+      def namespace
+        @namespace ||= NodeObjects::Namespace.new(self.ast)
+      end
+
+      # @return [NodeObjects::Namespace, nil]
+      def current_namespace
+        @current_namespace ||= namespace.calc_current_location_namespace(location)
+      end
+
+      # @return [NodeObjects::MethodDefition, nil]
+      def current_method
+        @current_method ||= namespace.calc_current_location_method(location)
+      end
+    end
+  end
+end

data/lib/yoda/parsing/source_cutter.rb

@@ -0,0 +1,231 @@
+module Yoda
+  module Parsing
+    class SourceCutter
+      class CannotRecoverError < StandardError; end
+
+      attr_reader :source, :current_location
+      def initialize(source, current_location)
+        @source = source
+        @current_location = current_location
+      end
+
+      # The last point of cut source.
+      # @return [Integer]
+      def cut_position
+        @cut_position ||= current_location_token_range.end_pos - 1
+      end
+
+      # @return [::Parser::Source::Range]
+      def current_location_token_range
+        @current_location_token_range ||= current_location_token.last.last
+      end
+
+      # @return [Integer]
+      def current_location_token_index
+        @current_location_token_index ||= begin
+          reverse_index = tokens_of_source.reverse_each.find_index { |type, (name, range)| current_location.later_than?(range) }
+          tokens_of_source.length - 1 - reverse_index
+        end
+      end
+
+      # @return [(Symbol, (String, ::Parser::Source::Range))]
+      def current_location_token
+        tokens_of_source[current_location_token_index]
+      end
+
+      # @return [Array<(Symbol, (String, ::Parser::Source::Range))>]
+      def tokens_of_source
+        @tokens_of_source ||= begin
+          _, _, tokens = ::Parser::CurrentRuby.new.tokenize(::Parser::Source::Buffer.new("(string)").tap { |b| b.source = source }, true)
+          tokens
+        end
+      end
+
+      # @return [String]
+      def cut_source
+        @cut_source ||= source.slice(0..cut_position)
+      end
+
+      # Returns a source that is made parsable from cut_source.
+      # @return [String]
+      def error_recovered_source
+        @error_recovered_source ||= recover_source
+      end
+
+      private
+
+      # @return [String]
+      def recover_source
+        remained_tokens = tokens_of_source.slice(0..current_location_token_index)
+        tokens_to_append = [:tSEMI]
+
+        while
+          fixing_source = FixingSource.new(cut_source, tokens_to_append)
+          case fixing_source.diagnostic
+          when :fix_line
+            remained_tokens, tokens_to_append = LineFixer.new.process(remained_tokens, tokens_to_append)
+          when :fix_block
+            tokens_to_append = BlockFixer.new.process(remained_tokens, tokens_to_append)
+            remained_tokens = []
+          else
+            return fixing_source.to_s
+          end
+        end
+      end
+
+      class FixingSource
+        attr_reader :source, :tokens_to_append
+        # @param source [String]
+        # @param tokens_to_append [Array<Symbol>]
+        def initialize(source, tokens_to_append)
+          @source = source
+          @tokens_to_append = tokens_to_append
+        end
+
+        def to_s
+          @to_s ||= source + "\n" + tokens_to_append.map(&token_mapper).join("\n")
+        end
+
+        def token_mapper
+          {
+            tSEMI: ';',
+            tLBRACE: '{',
+            tRBRACE: '}',
+            tLPAREN: '(',
+            tRPAREN: ')',
+            kEND: 'end',
+            kNIL: 'nil',
+            dummy_constant: 'DUMMY_CONSTANT',
+            dummy_method: 'dummy_method',
+          }
+        end
+
+        # @return [Symbol, nil]
+        def diagnostic
+          begin
+            ::Parser::CurrentRuby.parse(to_s)
+            nil
+          rescue ::Parser::SyntaxError => ex
+            fail CannotRecoverError, "Cannot recover: #{ex.diagnostic.render}" unless ex.diagnostic.reason == :unexpected_token
+            fail CannotRecoverError, "Cannot recover: #{ex.diagnostic.render}" unless ex.diagnostic.location.end_pos == to_s.length
+            case ex.diagnostic.arguments[:token]
+            when 'tSEMI'
+              :fix_line
+            when '$end'
+              :fix_block
+            else
+              fail CannotRecoverError, "Cannot recover: #{ex.diagnostic.render}"
+            end
+          end
+        end
+      end
+
+      class LineFixer
+        # @param remained_tokens [Array<(Symbol, (String, ::Parser::Source::Range))>]
+        # @param tokens_to_add   [Array<Symbol>]
+        def process(remained_tokens, tokens_to_add)
+          if tokens_to_add.first == :tSEMI
+            token = fix_operator(remained_tokens)
+            return [remained_tokens, [token] + tokens_to_add] if token
+          end
+
+          fix_inline_block(remained_tokens, tokens_to_add)
+        end
+
+        # @return [Symbol, nil]
+        def fix_operator(remained_tokens)
+          case remained_tokens.last.first
+          when :tEQL, :tAMPER2, :tPIPE, :tBANG, :tCARET, :tPLUS, :tMINUS, :tSTAR2, :tDIVIDE, :tPERCENT, :tTILDE, :tCOMMA, :tDOT2, :tDOT3, :tCOLON,
+              :tANDOP, :tOROP, :tUMINUS, :tUPLUS, :tTILDE, :tPOW, :tMATCH, :tNMATCH, :tEQ, :tNEQ, :tGT, :tRSHFT, :tGEQ, :tLT, :tLSHFT, :tLEQ, :tASSOC, :tEQQ, :tCMP, :tBANG, :tANDDOT
+            :kNIL
+          when :tCOLON2, :tCOLON3
+            :dummy_constant
+          when :tDOT
+            :dummy_method
+          else
+            nil
+          end
+        end
+
+        def fix_inline_block(remained_tokens, tokens_to_add)
+          stack = []
+
+          remained_tokens.each_with_index.reverse_each do |(token, _), i|
+            token_to_add =
+              case token
+              when :tSTRING_BEG
+                reduce(stack, :tSTRING_END)
+              when :tSTRING_END
+                reduce(stack, :tSTRING_END)
+              when :tLBRACE
+                reduce(stack, :tRBRACE)
+              when :tRBRACE
+                next stack.push(:tRBRACE)
+              when :tLPAREN, :tLPAREN2
+                reduce(stack, :tRPAREN)
+              when :tRPAREN, :tRPAREN2
+                next stack.push(:tRPAREN)
+              else
+                nil
+              end
+            return [remained_tokens.slice(0...i), tokens_to_add.slice(0..-2) + [token_to_add, tokens_to_add.last]] if token_to_add
+          end
+
+          fail CannotRecoverError, "Cannot fix inline error"
+        end
+
+        def reduce(stack, expected)
+          if stack.empty?
+            expected
+          else
+            if stack.last == expected
+              stack.pop
+            else
+              fail CannotRecoverError, "Block mismatch in existing source"
+            end
+            nil
+          end
+        end
+      end
+
+      class BlockFixer
+        def process(remained_tokens, tokens_to_add)
+          fail CannotRecoverError, "Cannot resolve block error" if remained_tokens.empty?
+          stack = []
+          tokens_to_add = tokens_to_add.dup
+
+          remained_tokens.each_with_index.reverse_each do |(token, _), i|
+            case token
+            when :kIF, :kUNLESS, :kWHILE, :kUNTIL, :kCLASS, :kFOR, :kBEGIN, :kCASE, :kCLASS, :kMODULE, :kDEF
+              reduce(stack, tokens_to_add, :kEND)
+            when :kDO
+              next if i > 0 && [:kWHILE, :kUNTIL, :kFOR].include?(remained_tokens[i].first)
+              reduce(stack, tokens_to_add, :kEND)
+            when :kEND
+              stack.push(:kEND)
+            when :tLBRACE, :tLCURLY
+              reduce(stack, tokens_to_add, :tRBRACE)
+            when :tRBRACE, :tRCURLY
+              stack.push(:tRBRACE)
+            end
+          end
+
+          fail CannotRecoverError, "Block mismatch in existing source" unless stack.empty?
+          tokens_to_add
+        end
+
+        def reduce(stack, tokens_to_add, expected)
+          if stack.empty?
+            tokens_to_add.push(expected)
+          else
+            if stack.last == expected
+              stack.pop
+            else
+              fail CannotRecoverError, "Block mismatch in existing source"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yoda/parsing/type_parser.rb

@@ -0,0 +1,141 @@
+require 'parslet'
+
+module Yoda
+  module Parsing
+    class TypeParser
+      # @return [Model::Types::Base]
+      def parse(str)
+        Generator.new.apply(Parser.new.parse(str))
+      end
+
+      # @return [Model::Types::Base, nil]
+      def safe_parse(str)
+        parse(str)
+      rescue Parslet::ParseFailed => failure
+        nil
+      end
+
+      class Parser < Parslet::Parser
+        rule(:space) { match('\s').repeat(1) }
+        rule(:space?) { space.maybe }
+
+        rule(:special_value) { str('void') | str('nil') | str('true') | str('false') }
+        rule(:any_type) { str('any').as(:any_type) }
+        rule(:keyword) { match['a-z'] >> match['a-zA-Z0-9_'].repeat(1) }
+        rule(:generic_name) { constant_name }
+        rule(:constant_name) { match['A-Z'] >> match['a-zA-Z0-9_'].repeat }
+        rule(:constant_full_name) { str('::').maybe >> (constant_name >> str('::')).repeat >> constant_name }
+
+        rule(:required_param) { type.as(:required) }
+        rule(:optional_param) { str('?') >> space? >> type.as(:optional) }
+        rule(:rest_param) { str('*') >> space? >> type.as(:rest) }
+        rule(:required_keyword_param) { keyword.as(:required_keyword) >> str(':') >> space? >> type.as(:type_for_keyword) }
+        rule(:optional_keyword_param) { keyword.as(:optinal_keyword) >> str('?:') >> space? >> type.as(:type_for_keyword) }
+        rule(:keyword_rest_param) { str('**') >> space? >> type.as(:keyword_rest) }
+        rule(:block_param) { str('&') >> space? >> type.as(:block) }
+
+        rule(:context) { str('(') >> space? >> type >> space? >> str(')') }
+        rule(:param) { keyword_rest_param | block_param | optional_param | rest_param | required_keyword_param | optional_keyword_param | required_param }
+        rule(:params_inner) { param >> (space? >> str(',') >> space? >> param).repeat }
+        rule(:params) { str('(') >> space? >> params_inner >> space? >> str(')') }
+        rule(:generic_abs) { str('<') >> space? >> generic_name >> (space? >> str(',') >> space? >> generic_name).repeat >> space? >> str('>') }
+        rule(:function_type_inner) { params.as(:params) >> space? >> str('->') >> space? >> type.as(:return_type) }
+        rule(:function_type_inner_with_context) { context.maybe.as(:context) >> space? >> function_type_inner }
+        rule(:function_type) { generic_abs.maybe.as(:generic_abs) >> space? >> (function_type_inner | function_type_inner_with_context).as(:generic_abs_body) }
+
+        rule(:self_instance_type) { str('self') >> space? >> str('.') >> space? >> str('instance') }
+        rule(:self_class_type) { str('self') >> space? >> str('.') >> space? >> str('class') }
+        rule(:self_type) { str('self') }
+
+        rule(:instance_type) { constant_full_name.as(:instance_type) }
+        rule(:module_type) { constant_full_name.as(:module_type) >> space? >> str('.') >> space? >> (str('class') | str('module')) }
+        rule(:value_type) { special_value.as(:value_type) }
+        rule(:sequence_type) { (str('[') >> space? >> type >> (space? >> str(',') >> space? >> type).repeat >> space? >> str(']')).as(:sequence_type) }
+
+        rule(:type_with_paren) { str('(') >> type >> str(')') }
+        rule(:simple_type) { function_type | type_with_paren | sequence_type | value_type | any_type | module_type | instance_type }
+
+        rule(:generic_type_params) { str('<') >> space? >> type >> (space? >> str(',') >> space? >> type).repeat >> space? >> str('>') }
+        rule(:generic_type) { simple_type.as(:base_type) >> (space? >> generic_type_params.as(:generic_type_params)).maybe }
+        rule(:type_without_union) { generic_type }
+        rule(:union_type) { (type_without_union >> (space? >> str('|') >> space? >> type).repeat(1)).as(:union_type) }
+
+        rule(:type) { union_type | generic_type }
+
+        rule(:base) { type }
+        root :base
+      end
+
+      class Generator < Parslet::Transform
+        rule(required: simple(:type)) { Param.new(:required, type) }
+        rule(optional: simple(:type)) { Param.new(:optional, type) }
+        rule(rest: simple(:type)) { Param.new(:rest, type) }
+        rule(required_keyword: simple(:keyword), type_for_keyword: simple(:type)) { Param.new(:keyword_required, type, keyword.to_s) }
+        rule(optional_keyword: simple(:keyword), type_for_keyword: simple(:type)) { Param.new(:keyword_optional, type, keyword.to_s) }
+        rule(keyword_rest: simple(:type)) { Param.new(:keyword_rest, type) }
+        rule(block: simple(:type)) { Param.new(:block, type) }
+
+        rule(context: simple(:context), params: sequence(:param_types), return_type: simple(:return_type)) { create_function_type(context, param_types, return_type) }
+        rule(context: simple(:context), params: simple(:param_type), return_type: simple(:return_type)) { create_function_type(context, [param_type], return_type) }
+        rule(params: sequence(:param_types), return_type: simple(:return_type)) { Generator.create_function_type(nil, param_types, return_type) }
+        rule(params: simple(:param_type), return_type: simple(:return_type)) { Generator.create_function_type(nil, [param_type], return_type) }
+
+        rule(instance_type: simple(:class_name)) { Model::Types::InstanceType.new(class_name.to_s) }
+        rule(module_type: simple(:module_name)) { Model::Types::ModuleType.new(module_name.to_s) }
+        rule(value_type: simple(:value_name)) { Model::Types::ValueType.new(value_name.to_s) }
+        rule(any_type: simple(:any)) { Model::Types::AnyType.new }
+
+        rule(sequence_type: simple(:type)) { Model::Types::SequenceType.new(Model::Types::InstanceType.new('::Array'), [type]) }
+        rule(sequence_type: sequence(:types)) { Model::Types::SequenceType.new(Model::Types::InstanceType.new('::Array'), types) }
+
+        rule(generic_abs: simple(:generic_abs), generic_abs_body: simple(:type)) { type }
+
+        rule(base_type: simple(:base_type)) { base_type }
+        rule(base_type: simple(:base_type), generic_type_params: simple(:type_param)) { Model::Types::GenericType.new(base_type, [type_param]) }
+        rule(base_type: simple(:base_type), generic_type_params: sequence(:type_params)) { Model::Types::GenericType.new(base_type, type_params) }
+        rule(union_type: sequence(:types)) { Model::Types::UnionType.new(types) }
+
+        def self.create_function_type(context, param_types, return_type)
+          func_options = param_types.each_with_object({ context: context, return_type: return_type }).with_index do |(param, func_options), index|
+            case param.kind
+            when :required
+              if func_options[:rest_parameter]
+                func_options[:post_parameters] ||= []
+                func_options[:post_parameters].push(param.type)
+              else
+                func_options[:required_parameters] ||= []
+                func_options[:required_parameters].push(param.type)
+              end
+            when :optional
+              func_options[:optional_parameters] ||= []
+              func_options[:optional_parameters].push(param.type)
+            when :rest
+              func_options[:rest_parameter] = param.type
+            when :required_keyword
+              func_options[:required_keyword_parameters] ||= []
+              func_options[:required_keyword_parameters].push(param.keyword, param.type)
+            when :optional_keyword
+              func_options[:optional_keyword_parameters] ||= []
+              func_options[:optional_keyword_parameters].push(param.keyword, param.type)
+            when :keyword_rest
+              func_options[:keyword_rest_parameter] = param.type
+            when :block
+              func_options[:block_parameter] = param.type
+            end
+          end
+
+          Model::Types::FunctionType.new(func_options)
+        end
+
+        class Param
+          attr_reader :kind, :type, :keyword
+          def initialize(kind, type, keyword = nil)
+            @kind = kind
+            @keyword = keyword
+            @type = type
+          end
+        end
+      end
+    end
+  end
+end