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;

  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, 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;

  std::size_t _formatting_tab_size;

  std::size_t _dist_plot_num_points;

  double _dist_plot_quantile_bound;
};