MooseServer.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html
 
#pragma once
 
#include "MooseApp.h"
#include "wasplsp/LSP.h"
#include "wasplsp/ServerImpl.h"
#include "wasplsp/Connection.h"
#include "libmesh/ignore_warnings.h"
#include "wasplsp/IOStreamConnection.h"
#include "libmesh/restore_warnings.h"
#include "waspcore/Object.h"
#include "wasphit/HITNodeView.h"
#include "waspsiren/SIRENInterpreter.h"
#include "waspsiren/SIRENResultSet.h"
#include "waspplot/CustomPlotFile.h"
#include <string>
#include <memory>
#include <set>
#include <map>
 
class MooseServer : public wasp::lsp::ServerImpl
{
public:
  MooseServer(MooseApp & moose_app);
 
  virtual ~MooseServer() = default;
 
  std::shared_ptr<wasp::lsp::Connection> getConnection() { return _connection; }
 
  MooseApp & getCheckApp();
 
  void setDistPlotNumPoints(std::size_t num_points) { _dist_plot_num_points = num_points; }
 
private:
  using SortedLocationNodes =
      std::set<wasp::HITNodeView,
               std::function<bool(const wasp::HITNodeView &, const wasp::HITNodeView &)>>;
 
  bool parseDocumentForDiagnostics(wasp::DataArray & diagnosticsList);
 
  void addResourcesForDocument();
 
  void getFileNameTypeValues(std::set<std::string> & filename_vals, wasp::HITNodeView parent);
 
  bool gatherDocumentCompletionItems(wasp::DataArray & completionItems,
                                     bool & is_incomplete,
                                     int line,
                                     int character);
 
  void getExistingInput(wasp::HITNodeView parent_node,
                        std::set<std::string> & existing_params,
                        std::set<std::string> & existing_subblocks);
 
  void getAllValidParameters(InputParameters & valid_params,
                             const std::string & object_path,
                             const std::string & object_type,
                             std::set<std::string> & obj_act_tasks);
 
  void getActionParameters(InputParameters & valid_params,
                           const std::string & object_path,
                           std::set<std::string> & obj_act_tasks);
 
  void getObjectParameters(InputParameters & valid_params,
                           std::string object_type,
                           const std::set<std::string> & obj_act_tasks);
 
  bool addParametersToList(wasp::DataArray & completionItems,
                           const InputParameters & valid_params,
                           const std::set<std::string> & existing_params,
                           int replace_line_beg,
                           int replace_char_beg,
                           int replace_line_end,
                           int replace_char_end,
                           const std::string & filtering_prefix);
 
  bool addSubblocksToList(wasp::DataArray & completionItems,
                          const std::string & object_path,
                          int replace_line_beg,
                          int replace_char_beg,
                          int replace_line_end,
                          int replace_char_end,
                          const std::string & filtering_prefix,
                          bool request_on_block_decl);
 
  bool addValuesToList(wasp::DataArray & completionItems,
                       const InputParameters & valid_params,
                       const std::set<std::string> & existing_params,
                       const std::set<std::string> & existing_subblocks,
                       const std::string & param_name,
                       const std::set<std::string> & obj_act_tasks,
                       const std::string & object_path,
                       int replace_line_beg,
                       int replace_char_beg,
                       int replace_line_end,
                       int replace_char_end);
 
  template <typename MooseEnumType>
  void getEnumsAndDocs(MooseEnumType & moose_enum_param,
                       std::map<std::string, std::string> & options_and_descs);
 
  void addObjectsFromWarehouses(const std::string & param_type,
                                std::map<std::string, std::string> & options_and_descs);
 
  bool
  gatherDocumentDefinitionLocations(wasp::DataArray & definitionLocations, int line, int character);
 
  void getInputLookupDefinitionNodes(SortedLocationNodes & location_nodes,
                                     const std::string & clean_type,
                                     const std::string & val_string);
 
  bool addLocationNodesToList(wasp::DataArray & defsOrRefsLocations,
                              const SortedLocationNodes & location_nodes);
 
  bool getHoverDisplayText(std::string & display_text, int line, int character);
 
  bool gatherDocumentReferencesLocations(wasp::DataArray & referencesLocations,
                                         int line,
                                         int character,
                                         bool include_declaration);
 
  void getNodesByValueAndTypes(SortedLocationNodes & match_nodes,
                               wasp::HITNodeView view_parent,
                               const std::string & target_value,
                               const std::set<std::string> & target_types);
 
  bool gatherDocumentFormattingTextEdits(wasp::DataArray & formattingTextEdits,
                                         int tab_size,
                                         bool insert_spaces);
 
  std::string formatDocument(wasp::HITNodeView parent, std::size_t & prev_line, std::size_t level);
 
  bool gatherDocumentSymbols(wasp::DataArray & documentSymbols);
 
  bool traverseParseTreeAndFillSymbols(wasp::HITNodeView view_parent,
                                       wasp::DataObject & data_parent);
 
  int getCompletionItemKind(const InputParameters & valid_params,
                            const std::string & param_name,
                            const std::string & clean_type,
                            bool is_param);
 
  int getDocumentSymbolKind(wasp::HITNodeView symbol_node);
 
  std::string getRequiredParamsText(const std::string & subblock_path,
                                    const std::string & subblock_type,
                                    const std::set<std::string> & existing_params,
                                    const std::string & indent_spaces);
 
  bool gatherExtensionResponses(wasp::DataArray & extensionResponses,
                                const std::string & extensionMethod,
                                int line,
                                int character);
 
  bool gatherPlottingResponses(wasp::DataArray & plotting_responses, int line, int character);
 
  void buildFuncPlotResponse(wasp::DataArray & plotting_responses,
                             FEProblemBase & problem,
                             const std::string & object_name,
                             const std::string & object_type);
 
  void buildDistPlotResponses(wasp::DataArray & plotting_responses,
                              FEProblemBase & problem,
                              const std::string & object_name,
                              const std::string & object_type);
 
  void buildLineGraphPlot(wasp::CustomPlot & plot_object,
                          const std::string & plot_title,
                          const std::string & x_axis_label,
                          const std::string & y_axis_label,
                          const std::vector<double> & graph_keys,
                          const std::vector<double> & graph_vals);
 
  bool connectionRead(wasp::DataObject & object) { return _connection->read(object, errors); }
 
  bool connectionWrite(wasp::DataObject & object) { return _connection->write(object, errors); }
 
  bool rootIsValid() const;
 
  MooseApp & getRegistrationApp();
 
  struct SyntaxMetadata
  {
    std::map<std::string, std::set<std::string>> syntax_to_subblocks;
    std::map<std::string, std::set<std::string>> type_to_input_paths;
    std::map<std::string, std::set<std::string>> input_path_to_types;
  };
 
  SyntaxMetadata & getSyntaxMetadata();
 
  struct CheckState
  {
    CheckState(std::shared_ptr<Parser> & parser) : parser(parser) {}
    std::shared_ptr<Parser> parser;
    std::unique_ptr<MooseApp> app;
  };
 
  const CheckState * queryCheckState() const;
  CheckState * queryCheckState();
 
  const MooseApp * queryCheckApp() const;
  MooseApp * queryCheckApp();
 
  const Parser * queryCheckParser() const;
  Parser * queryCheckParser();
 
  const hit::Node * queryRoot() const;
 
  const hit::Node & getRoot() const;
 
  MooseApp & _moose_app;
 
  std::map<std::string, CheckState> _check_state;
 
  std::shared_ptr<wasp::lsp::IOStreamConnection> _connection;
 
  std::map<std::string, SyntaxMetadata> _app_type_to_syntax_metadata;
 
  std::size_t _formatting_tab_size;
 
  std::size_t _dist_plot_num_points;
 
  double _dist_plot_quantile_bound;
};