(GH-166) Add find definition for types and functions

glennsarti · glennsarti · commit 705303d58b21 · 2018-01-03T09:20:03.000+08:00
Previously the Language Server did not respond to find definition requests from
the client.  This commit
* Adds a request handler for the textDocument/definition request
* A definition provider class which will extract the definition
* Monkey patch Type and Function loading so the language server can determine
  where types and functions came from
* Added definition provider as a language server capability

This commit adds parsing of puppet manifests for classes and defined types for
manifests that exist in the module path.
* The classes are loading async if preload is configured
* Will respond to definition requests if a type with the same name could not be
  found
diff --git a/server/lib/languageserver/languageserver.rb b/server/lib/languageserver/languageserver.rb
@@ -1,4 +1,4 @@
-%w[constants diagnostic completion_list completion_item hover puppet_version puppet_compilation].each do |lib|
+%w[constants diagnostic completion_list completion_item hover location puppet_version puppet_compilation].each do |lib|
   begin
     require "languageserver/#{lib}"
   rescue LoadError
diff --git a/server/lib/languageserver/location.rb b/server/lib/languageserver/location.rb
@@ -0,0 +1,30 @@
+module LanguageServer
+  #  /**
+  #  * The result of a hover request.
+  #  */
+  # export interface Location {
+  #   uri: string;
+  #   range: Range;
+  # }
+
+  module Location
+    def self.create(options)
+      result = {}
+      raise('uri is a required field for Location') if options['uri'].nil?
+
+      result['uri'] = options['uri']
+      result['range'] = {
+        'start' => {
+          'line' => options['fromline'],
+          'character' => options['fromchar']
+        },
+        'end' => {
+          'line'      => options['toline'],
+          'character' => options['tochar']
+        }
+      }
+
+      result
+    end
+  end
+end
diff --git a/server/lib/puppet-languageserver.rb b/server/lib/puppet-languageserver.rb
@@ -5,8 +5,8 @@
   require 'languageserver/languageserver'
   require 'puppet-vscode'
 
-  %w[json_rpc_handler message_router server_capabilities document_validator
-    puppet_parser_helper puppet_helper facter_helper completion_provider hover_provider].each do |lib|
+  %w[json_rpc_handler message_router server_capabilities document_validator puppet_parser_helper puppet_helper 
+    facter_helper completion_provider hover_provider definition_provider puppet_monkey_patches].each do |lib|
     begin
       require "puppet-languageserver/#{lib}"
     rescue LoadError
@@ -126,6 +126,9 @@ def self.init_puppet_worker(options)
 
       log_message(:info, 'Preloading Functions (Async)...')
       PuppetLanguageServer::PuppetHelper.load_functions_async
+
+      log_message(:info, 'Preloading Classes (Async)...')
+      PuppetLanguageServer::PuppetHelper.load_classes_async
     else
       log_message(:info, 'Skipping preloading Puppet')
     end
diff --git a/server/lib/puppet-languageserver/definition_provider.rb b/server/lib/puppet-languageserver/definition_provider.rb
@@ -0,0 +1,83 @@
+module PuppetLanguageServer
+  module DefinitionProvider
+    def self.find_definition(content, line_num, char_num)
+      result = PuppetLanguageServer::PuppetParserHelper.object_under_cursor(content, line_num, char_num, false, [Puppet::Pops::Model::BlockExpression])
+
+      return nil if result.nil?
+
+      path = result[:path]
+      item = result[:model]
+
+      response = []
+      case item.class.to_s
+      when 'Puppet::Pops::Model::CallNamedFunctionExpression'
+        func_name = item.functor_expr.value
+        response << function_name(resource_name)
+
+      when 'Puppet::Pops::Model::QualifiedName'
+        # Qualified names could be anything.  Context is the key here
+        parent = path.last
+
+        # What if it's a function name.  Then the Qualified name must be the same as the function name
+        if !parent.nil? &&
+          parent.class.to_s == 'Puppet::Pops::Model::CallNamedFunctionExpression' &&
+          parent.functor_expr.value == item.value
+            func_name = item.value
+            response << function_name(func_name)
+        end
+        # What if it's an "include <class>" call
+        if !parent.nil? && parent.class.to_s == 'Puppet::Pops::Model::CallNamedFunctionExpression' && parent.functor_expr.value == 'include'
+          resource_name = item.value
+          response << type_or_class(resource_name)
+        end
+        # What if it's the name of a resource type or class
+        if !parent.nil? && parent.class.to_s == 'Puppet::Pops::Model::ResourceExpression'
+          resource_name = item.value
+          response << type_or_class(resource_name)
+        end
+
+      when 'Puppet::Pops::Model::ResourceExpression'
+        resource_name = item.type_name.value
+        response << type_or_class(resource_name)
+
+      else
+        raise "Unable to generate Defintion information for object of type #{item.class}"
+      end
+
+      response.compact
+    end
+
+    private
+    def self.type_or_class(resource_name)
+      # Strip the leading double-colons for root resource names
+      resource_name = resource_name.slice(2, resource_name.length - 2) if resource_name.start_with?('::')
+      location = PuppetLanguageServer::PuppetHelper.type_load_info(resource_name)
+      location = PuppetLanguageServer::PuppetHelper.class_load_info(resource_name) if location.nil?
+      unless location.nil?
+        return LanguageServer::Location.create({
+          'uri' => 'file:///' + location['source'],
+          'fromline' => location['line'],
+          'fromchar' => 0,
+          'toline' => location['line'],
+          'tochar' => 1024,
+        })
+      end
+      nil
+    end
+
+    def self.function_name(func_name)
+      location = PuppetLanguageServer::PuppetHelper.function_load_info(func_name)
+      unless location.nil?
+        return LanguageServer::Location.create({
+          'uri' => 'file:///' + location['source'],
+          'fromline' => location['line'],
+          'fromchar' => 0,
+          'toline' => location['line'],
+          'tochar' => 1024,
+        })
+      end
+      nil
+    end
+
+  end
+end
diff --git a/server/lib/puppet-languageserver/message_router.rb b/server/lib/puppet-languageserver/message_router.rb
@@ -184,6 +184,20 @@ def receive_request(request)
           PuppetLanguageServer.log_message(:error, "(textDocument/hover) #{exception}")
           request.reply_result(LanguageServer::Hover.create_nil_response)
         end
+
+      when 'textDocument/definition'
+        file_uri = request.params['textDocument']['uri']
+        line_num = request.params['position']['line']
+        char_num = request.params['position']['character']
+        content = documents.document(file_uri)
+        begin
+          #raise "Not Implemented"
+          request.reply_result(PuppetLanguageServer::DefinitionProvider.find_definition(content, line_num, char_num))
+        rescue StandardError => exception
+          PuppetLanguageServer.log_message(:error, "(textDocument/definition) #{exception}")
+          request.reply_result($null)
+        end
+
       else
         PuppetLanguageServer.log_message(:error, "Unknown RPC method #{request.rpc_method}")
       end
diff --git a/server/lib/puppet-languageserver/puppet_helper.rb b/server/lib/puppet-languageserver/puppet_helper.rb
@@ -1,15 +1,20 @@
 require 'puppet/indirector/face'
-
+require 'pathname'
 module PuppetLanguageServer
   module PuppetHelper
     # Reference - https://github.com/puppetlabs/puppet/blob/master/lib/puppet/reference/type.rb
 
     @ops_lock_types = Mutex.new
     @ops_lock_funcs = Mutex.new
+    @ops_lock_classes = Mutex.new
     @types_hash = nil
     @function_module = nil
     @types_loaded = nil
     @functions_loaded = nil
+    @classes_loaded = nil
+    @class_load_info = {}
+    @function_load_info = {}
+    @type_load_info = {}
 
     def self.reset
       @ops_lock_types.synchronize do
@@ -114,13 +119,60 @@ def self.function_names
       result
     end
 
+    # Classes and Defined Types
+    def self.classes_loaded?
+      @classes_loaded.nil? ? false : @classes_loaded
+    end
+
+    def self.load_classes
+      @ops_lock_classes.synchronize do
+        _load_classes if @classes_loaded.nil?
+      end
+    end
+
+    def self.load_classes_async
+      Thread.new do
+        load_classes
+      end
+    end
+
+    # Loading information
+    def self.add_function_load_info(name, options)
+      @function_load_info[name.to_s] = options
+    end
+
+    def self.function_load_info(name)
+      options = @function_load_info[name.to_s]
+      options.nil? ? nil : options.dup
+    end
+
+    def self.add_type_load_info(name, options)
+      @type_load_info[name.to_s] = options
+    end
+
+    def self.type_load_info(name)
+      options = @type_load_info[name.to_s]
+      options.nil? ? nil : options.dup
+    end
+
+    def self.class_load_info(name)
+      # This is the only entrypoint to class loading
+      load_classes
+      options = @class_load_info[name.to_s]
+      options.nil? ? nil : options.dup
+    end
+
     # DO NOT ops_lock on any of these methods
     # deadlocks will ensue!
     def self._reset
       @types_hash = nil
       @function_module = nil
       @types_loaded = nil
       @functions_loaded = nil
+      @classes_loaded = nil
+      @function_load_info = {}
+      @type_load_info = {}
+      @class_load_info = {}
     end
     private_class_method :_reset
 
@@ -134,6 +186,126 @@ def self.prune_resource_parameters(resources)
     end
     private_class_method :prune_resource_parameters
 
+    # Class and Defined Type loading
+    def self._load_classes
+      @classes_loaded = false
+      module_path_list = []
+      # Add the base modulepath
+      module_path_list.concat(Puppet::Node::Environment.split_path(Puppet.settings[:basemodulepath]))
+      # Add the modulepath
+      module_path_list.concat(Puppet::Node::Environment.split_path(Puppet.settings[:modulepath]))
+
+      # Add the environment specified in puppet conf - This can be overridden by the master but there's no way to know.
+      unless Puppet.settings[:environmentpath].nil?
+        module_path_list << File.join(Puppet.settings[:environmentpath], Puppet.settings[:environment], 'modules') unless Puppet.settings[:environment].nil?
+
+        module_path_list.concat(Pathname.new(Puppet.settings[:environmentpath])
+                                  .children
+                                  .select { |c| c.directory? }
+                                  .collect { |c| File.join(c, 'modules') }
+                               )
+      end
+      module_path_list.uniq!
+      PuppetLanguageServer.log_message(:debug, "[PuppetHelper::_load_classes] Loading classes from #{module_path_list}")
+
+      # Find all of the manifest paths for all of the modules...
+      manifest_path_list = []
+      module_path_list.each do |module_path|
+        next unless File.exists?(module_path)
+        Pathname.new(module_path)
+          .children
+          .select { |c| c.directory? }
+          .each do |module_filepath|
+            manifest_path = File.join(module_filepath,'manifests')
+            manifest_path_list << manifest_path if File.exists?(manifest_path)
+          end
+      end
+
+      # Find and parse all manifests in the manifest paths
+      @class_load_info = {}
+      manifest_path_list.each do |manifest_path|
+        Dir.glob("#{manifest_path}/**/*.pp").each do |manifest_file|
+          classes = load_classes_from_manifest(manifest_file)
+          next if classes.nil?
+          classes.each do |key, data|
+            @class_load_info[key] = data unless @class_load_info.has_key?(name)
+          end
+        end
+      end
+      @classes_loaded = true
+
+      PuppetLanguageServer.log_message(:debug, "[PuppetHelper::_load_classes] Finished loading #{@class_load_info.count} classes")
+      nil
+    end
+    private_class_method :_load_classes
+
+    def self.load_classes_from_manifest(manifest_file)
+      file_content = File.open(manifest_file, "r:UTF-8") { |f| f.read }
+
+      parser = Puppet::Pops::Parser::Parser.new
+      result = nil
+      begin
+        result = parser.parse_string(file_content, '')
+      rescue Puppet::ParseErrorWithIssue => _exception
+        # Any parsing errors means we can't inspect the document
+        return nil
+      end
+
+      class_info = {}
+      # Enumerate the entire AST looking for classes and defined types
+      # TODO - Need to learn how to read the help/docs for hover support
+      if result.model.respond_to? :eAllContents
+        # TODO Puppet 4 language stuff
+        result.model.eAllContents.select do |item|
+          case item.class.to_s
+          when 'Puppet::Pops::Model::HostClassDefinition'
+            class_info[item.name] = {
+              'name' => item.name,
+              'type' => 'class',
+              'parameters' => item.parameters,
+              'source' => manifest_file,
+              'line' => result.locator.line_for_offset(item.offset) - 1,
+              'char' => result.locator.offset_on_line(item.offset)
+            }
+          when 'Puppet::Pops::Model::ResourceTypeDefinition'
+            class_info[item.name] = {
+              'name' => item.name,
+              'type' => 'typedefinition',
+              'parameters' => item.parameters,
+              'source' => manifest_file,
+              'line' => result.locator.line_for_offset(item.offset) - 1,
+              'char' => result.locator.offset_on_line(item.offset)
+            }
+          end
+        end
+      else
+        result.model._pcore_all_contents([]) do |item|
+          case item.class.to_s
+          when 'Puppet::Pops::Model::HostClassDefinition'
+            class_info[item.name] = {
+              'name' => item.name,
+              'type' => 'class',
+              'parameters' => item.parameters,
+              'source' => manifest_file,
+              'line' => item.line,
+              'char' => item.pos
+            }
+          when 'Puppet::Pops::Model::ResourceTypeDefinition'
+            class_info[item.name] = {
+              'name' => item.name,
+              'type' => 'typedefinition',
+              'parameters' => item.parameters,
+              'source' => manifest_file,
+              'line' => item.line,
+              'char' => item.pos
+            }
+          end
+        end
+      end
+
+      class_info
+    end
+
     def self._load_types
       @types_loaded = false
       @types_hash = {}
diff --git a/server/lib/puppet-languageserver/puppet_monkey_patches.rb b/server/lib/puppet-languageserver/puppet_monkey_patches.rb
diff --git a/server/lib/puppet-languageserver/server_capabilities.rb b/server/lib/puppet-languageserver/server_capabilities.rb

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-%w[constants diagnostic completion_list completion_item hover puppet_version puppet_compilation].each do \|lib\|`
	`1`	`+%w[constants diagnostic completion_list completion_item hover location puppet_version puppet_compilation].each do \|lib\|`
`2`	`2`	`begin`
`3`	`3`	`require "languageserver/#{lib}"`
`4`	`4`	`rescue LoadError`