MooseServer Class Reference

#include <MooseServer.h>

Inheritance diagram for MooseServer:

Classes
struct	CheckState
	Helper for storing the state for a single document. More...
struct	SyntaxMetadata
	struct to store syntax metadata for each registration application type More...

Public Member Functions
	MooseServer (MooseApp &moose_app)
virtual	~MooseServer ()=default
std::shared_ptr< wasp::lsp::Connection >	getConnection ()
	Get read / write connection - specific to this server implemention.
MooseApp &	getCheckApp ()
	Public interface for writable check app reference with error checks.
void	setDistPlotNumPoints (std::size_t num_points)
	Override number of discrete points in continuous distribution plots.

Private Types
using	SortedLocationNodes = std::set< wasp::HITNodeView, std::function< bool(const wasp::HITNodeView &, const wasp::HITNodeView &)> >
	SortedLocationNodes - type alias for set of nodes sorted by location.

Private Member Functions
bool	parseDocumentForDiagnostics (wasp::DataArray &diagnosticsList)
	Parse document for diagnostics - specific to this server implemention.
void	addResourcesForDocument ()
	Add paths from includes and FileName parameters for client to watch.
void	getFileNameTypeValues (std::set< std::string > &filename_vals, wasp::HITNodeView parent)
	Recursively walk input to gather all FileName type parameter values.
bool	gatherDocumentCompletionItems (wasp::DataArray &completionItems, bool &is_incomplete, int line, int character)
	Gather document completion items - specific to this server implemention.
void	getExistingInput (wasp::HITNodeView parent_node, std::set< std::string > &existing_params, std::set< std::string > &existing_subblocks)
	Get names of parameters and subblocks specified in given input node.
void	getAllValidParameters (InputParameters &valid_params, const std::string &object_path, const std::string &object_type, std::set< std::string > &obj_act_tasks)
	Get all global parameters, action parameters, and object parameters.
void	getActionParameters (InputParameters &valid_params, const std::string &object_path, std::set< std::string > &obj_act_tasks)
	Get all action parameters using requested object path to collection.
void	getObjectParameters (InputParameters &valid_params, std::string object_type, const std::set< std::string > &obj_act_tasks)
	Get all object parameters using requested object path to collection.
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)
	Add parameters that were previously gathered to list for completion.
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)
	Add subblocks to completion list for request path, line, and column.
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)
	Add parameter values to completion list for request line and column.
template<typename MooseEnumType >
void	getEnumsAndDocs (MooseEnumType &moose_enum_param, std::map< std::string, std::string > &options_and_descs)
	Fill map of all options and descriptions if parameter is moose enum.
void	addObjectsFromWarehouses (const std::string &param_type, std::map< std::string, std::string > &options_and_descs)
	Supplement completion list with objects in warehouses if applicable.
bool	gatherDocumentDefinitionLocations (wasp::DataArray &definitionLocations, int line, int character)
	Gather definition locations - specific to this server implemention.
void	getInputLookupDefinitionNodes (SortedLocationNodes &location_nodes, const std::string &clean_type, const std::string &val_string)
	Get set of nodes from associated path lookups matching value string.
bool	addLocationNodesToList (wasp::DataArray &defsOrRefsLocations, const SortedLocationNodes &location_nodes)
	Add set of nodes sorted by location to definition or reference list.
bool	getHoverDisplayText (std::string &display_text, int line, int character)
	Get hover display text - logic specific to this server implemention.
bool	gatherDocumentReferencesLocations (wasp::DataArray &referencesLocations, int line, int character, bool include_declaration)
	Gather references locations - specific to this server implemention.
void	getNodesByValueAndTypes (SortedLocationNodes &match_nodes, wasp::HITNodeView view_parent, const std::string &target_value, const std::set< std::string > &target_types)
	Recursively walk input to gather all nodes matching value and types.
bool	gatherDocumentFormattingTextEdits (wasp::DataArray &formattingTextEdits, int tab_size, bool insert_spaces)
	Gather formatting text edits - specific to this server implemention.
std::string	formatDocument (wasp::HITNodeView parent, std::size_t &prev_line, std::size_t level)
	Recursively walk down whole nodeview tree while formatting document.
bool	gatherDocumentSymbols (wasp::DataArray &documentSymbols)
	Gather document symbols - specific to this server implemention.
bool	traverseParseTreeAndFillSymbols (wasp::HITNodeView view_parent, wasp::DataObject &data_parent)
	Recursively fill document symbols from the given node.
int	getCompletionItemKind (const InputParameters &valid_params, const std::string &param_name, const std::string &clean_type, bool is_param)
	Get completion item kind value that client may use for icon in list.
int	getDocumentSymbolKind (wasp::HITNodeView symbol_node)
	Get document symbol kind value that client may use for outline icon.
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)
	Get required parameter completion text list for given subblock path.
bool	gatherExtensionResponses (wasp::DataArray &extensionResponses, const std::string &extensionMethod, int line, int character)
	Gather extension responses - specific to this server implemention.
bool	gatherPlottingResponses (wasp::DataArray &plotting_responses, int line, int character)
	Build CustomPlot extension responses when method name is plotting.
void	buildFuncPlotResponse (wasp::DataArray &plotting_responses, FEProblemBase &problem, const std::string &object_name, const std::string &object_type)
	Gather function data, build CustomPlot object, and add to responses.
void	buildDistPlotResponses (wasp::DataArray &plotting_responses, FEProblemBase &problem, const std::string &object_name, const std::string &object_type)
	Compute PDF and CDF, build CustomPlot objects, and add to responses.
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)
	Build CustomPlot graph with provided keys, values, and plot title.
bool	connectionRead (wasp::DataObject &object)
	Read from connection into object - specific to this server's connection.
bool	connectionWrite (wasp::DataObject &object)
	Write object json to connection - specific to this server's connection.
bool	rootIsValid () const
MooseApp &	getRegistrationApp ()
SyntaxMetadata &	getSyntaxMetadata ()
const hit::Node *	queryRoot () const
const hit::Node &	getRoot () const
const CheckState *	queryCheckState () const
CheckState *	queryCheckState ()
const MooseApp *	queryCheckApp () const
MooseApp *	queryCheckApp ()
const Parser *	queryCheckParser () const
Parser *	queryCheckParser ()

Private Attributes
MooseApp &	_moose_app
	_moose_app - reference to parent application that owns this server
std::map< std::string, CheckState >	_check_state
	_check_state - map from document paths to state (parser, app, text)
std::shared_ptr< wasp::lsp::IOStreamConnection >	_connection
	_connection - shared pointer to this server's read / write iostream
std::map< std::string, SyntaxMetadata >	_app_type_to_syntax_metadata
	_app_type_to_syntax_metadata - syntax metadata per app type map
std::size_t	_formatting_tab_size
	_formatting_tab_size - number of indent spaces for formatting
std::size_t	_dist_plot_num_points
	_dist_plot_num_points - distribution plot sampling resolution
double	_dist_plot_quantile_bound
	_dist_plot_quantile_bound - epsilon to bound plot range tails

Detailed Description

Definition at line 29 of file MooseServer.h.

Member Typedef Documentation

SortedLocationNodes

using MooseServer::SortedLocationNodes = std::set<wasp::HITNodeView, std::function<bool(const wasp::HITNodeView &, const wasp::HITNodeView &)> >

private

SortedLocationNodes - type alias for set of nodes sorted by location.

Definition at line 59 of file MooseServer.h.

Constructor & Destructor Documentation

MooseServer()

MooseServer::MooseServer

(

MooseApp &

moose_app

)

Definition at line 51 of file MooseServer.C.

  : _moose_app(moose_app),
    _connection(std::make_shared<wasp::lsp::IOStreamConnection>(this)),
    _formatting_tab_size(0),
    _dist_plot_num_points(200),
    _dist_plot_quantile_bound(1e-3)
{
  // add all implemented server capabilities to notify client in initialize
  enableFullSync();
  enableSymbols();
  enableCompletion();
  enableDefinition();
  enableReferences();
  enableFormatting();
  enableHover();
  enableExtension("plotting");
  enableExtension("watcherRegistration");
}

~MooseServer()

virtual MooseServer::~MooseServer ( )

virtualdefault

Member Function Documentation

addLocationNodesToList()

bool MooseServer::addLocationNodesToList ( wasp::DataArray &  defsOrRefsLocations, const SortedLocationNodes &  location_nodes  )

private

Add set of nodes sorted by location to definition or reference list.

Parameters

defsOrRefsLocations	- data array of locations objects to fill
location_nodes	- set of nodes that have locations to be added

Returns

- true if filling of location objects completed successfully

Definition at line 1313 of file MooseServer.C.

{
  bool pass = true;
 
  // walk over set of sorted nodes provided to add and build locations list
  for (const auto & location_nodes_iter : location_nodes)
  {
    // add file scheme prefix onto front of file path to build location uri
    auto location_uri = wasp::lsp::m_uri_prefix + location_nodes_iter.node_pool()->stream_name();
 
    // add file uri with zero based line and column range to locations list
    defsOrRefsLocations.push_back(wasp::DataObject());
    wasp::DataObject * location = defsOrRefsLocations.back().to_object();
    pass &= wasp::lsp::buildLocationObject(*location,
                                           errors,
                                           location_uri,
                                           location_nodes_iter.line() - 1,
                                           location_nodes_iter.column() - 1,
                                           location_nodes_iter.last_line() - 1,
                                           location_nodes_iter.last_column());
  }
 
  return pass;
}

Referenced by gatherDocumentDefinitionLocations(), and gatherDocumentReferencesLocations().

addObjectsFromWarehouses()

void MooseServer::addObjectsFromWarehouses ( const std::string &  param_type, std::map< std::string, std::string > &  options_and_descs  )

private

Supplement completion list with objects in warehouses if applicable.

Parameters

param_type	- parameter type string to pick suitable warehouse
options_and_descs	- map to fill with options and descriptions

Definition at line 1090 of file MooseServer.C.

{
  // get check app of document and return with no items if its build failed
  auto app_ptr = queryCheckApp();
  if (!app_ptr)
    return;
 
  // get problem from action warehouse and return without any items if null
  std::shared_ptr<FEProblemBase> & problem = app_ptr->actionWarehouse().problemBase();
  if (!problem)
    return;
 
  if (param_type == "NonlinearVariableName")
  {
    for (const auto i : make_range(problem->numNonlinearSystems()))
      for (const auto & nls_var_name : problem->getNonlinearSystemBase(i).getVariableNames())
        options_and_descs[nls_var_name] = "from NonlinearSystem VariableWarehouse";
  }
  else if (param_type == "AuxVariableName")
  {
    for (const auto & aux_var_name : problem->getAuxiliarySystem().getVariableNames())
      options_and_descs[aux_var_name] = "from AuxiliarySystem VariableWarehouse";
  }
  else if (param_type == "VariableName")
  {
    for (const auto i : make_range(problem->numNonlinearSystems()))
      for (const auto & nls_var_name : problem->getNonlinearSystemBase(i).getVariableNames())
        options_and_descs[nls_var_name] = "from NonlinearSystem VariableWarehouse";
    for (const auto & aux_var_name : problem->getAuxiliarySystem().getVariableNames())
      options_and_descs[aux_var_name] = "from AuxiliarySystem VariableWarehouse";
  }
  else if (param_type == "MaterialPropertyName")
  {
    const auto & mat_prop_registry = problem->getMaterialPropertyRegistry();
    const std::vector<std::string> mat_prop_names(mat_prop_registry.idsToNamesBegin(),
                                                  mat_prop_registry.idsToNamesEnd());
    for (const auto & mat_prop_name : mat_prop_names)
      options_and_descs[mat_prop_name] = "from MaterialPropertyRegistry";
  }
  else if (param_type == "MaterialName")
  {
    for (const auto & material : problem->getMaterialWarehouse().getObjects())
      options_and_descs[material->name()] = "from MaterialWarehouse";
  }
  else if (param_type == "FunctionName")
  {
    for (const auto & function : problem->getFunctionWarehouse().getObjects())
      options_and_descs[function->name()] = "from FunctionWarehouse";
  }
  else if (param_type == "OutputName")
  {
    for (const auto & output_name : app_ptr->getOutputWarehouse().getOutputNames<Output>())
      options_and_descs[output_name] = "from OutputWarehouse";
    for (const auto & reserved_name : app_ptr->getOutputWarehouse().getReservedNames())
      options_and_descs[reserved_name] = "from reserved names in OutputWarehouse";
  }
  else if (param_type == "UserObjectName")
  {
    std::vector<UserObject *> user_objects;
    problem->theWarehouse()
        .query()
        .condition<AttribSystem>("UserObject")
        .condition<AttribThread>(0)
        .queryIntoUnsorted(user_objects);
    for (const auto & user_object : user_objects)
      options_and_descs[user_object->name()] = "from UserObjectWarehouse";
  }
}

Referenced by addValuesToList().

addParametersToList()

bool MooseServer::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  )

private

Add parameters that were previously gathered to list for completion.

Parameters

completionItems	- list of completion objects to be filled out
valid_params	- all valid parameters to add to completion list
existing_params	- set of parameters already existing in input
replace_line_beg	- start line of autocompletion replace range
replace_char_beg	- start column of autocomplete replace range
replace_line_end	- end line of autocomplete replacement range
replace_char_end	- end column of autocompletion replace range
filtering_prefix	- beginning text to filter list if not empty

Returns

- true if filling of completion items completed successfully

Definition at line 685 of file MooseServer.C.

{
  bool pass = true;
 
  // walk over collection of all valid parameters and build completion list
  for (const auto & valid_params_iter : valid_params)
  {
    const std::string & param_name = valid_params_iter.first;
    bool deprecated = valid_params.isParamDeprecated(param_name);
    bool is_private = valid_params.isPrivate(param_name);
 
    // filter out parameters that are deprecated, private, or already exist
    if (deprecated || is_private || existing_params.count(param_name))
      continue;
 
    // filter out parameters that do not begin with prefix if one was given
    if (param_name.rfind(filtering_prefix, 0) != 0)
      continue;
 
    // process parameter description and type to use in input default value
    std::string dirty_type = valid_params.type(param_name);
    std::string clean_type = MooseUtils::prettyCppType(dirty_type);
    std::string basic_type = JsonSyntaxTree::basicCppType(clean_type);
    std::string doc_string = valid_params.getDocString(param_name);
    MooseUtils::escape(doc_string);
 
    // use basic type to decide if parameter is array and quotes are needed
    bool is_array = basic_type.compare(0, 6, "Array:") == 0;
 
    // remove any array prefixes from basic type string and leave base type
    pcrecpp::RE("(Array:)*(.*)").GlobalReplace("\\2", &basic_type);
 
    // prepare clean cpp type string to be used for key to find input paths
    pcrecpp::RE(".+<([A-Za-z0-9_' ':]*)>.*").GlobalReplace("\\1", &clean_type);
 
    // decide completion item kind that client may use to display list icon
    int complete_kind = getCompletionItemKind(valid_params, param_name, clean_type, true);
 
    // default value for completion to be built using parameter information
    std::string default_value;
 
    // first if parameter default is set then use it to build default value
    if (valid_params.isParamValid(param_name))
    {
      default_value = JsonSyntaxTree::buildOutputString(valid_params_iter);
      default_value = MooseUtils::trim(default_value);
    }
 
    // otherwise if parameter has coupled default then use as default value
    else if (valid_params.hasDefaultCoupledValue(param_name))
    {
      std::ostringstream oss;
      oss << valid_params.defaultCoupledValue(param_name);
      default_value = oss.str();
    }
 
    // switch 1 to true or 0 to false if boolean parameter as default value
    if (basic_type == "Boolean" && default_value == "1")
      default_value = "true";
    else if (basic_type == "Boolean" && default_value == "0")
      default_value = "false";
 
    // wrap default value with single quotes if it exists and type is array
    std::string array_quote = is_array && !default_value.empty() ? "'" : "";
 
    // choose format of insertion text based on if client supports snippets
    int text_format;
    std::string insert_text;
    if (client_snippet_support && !default_value.empty())
    {
      text_format = wasp::lsp::m_text_format_snippet;
      insert_text = param_name + " = " + array_quote + "${1:" + default_value + "}" + array_quote;
    }
    else
    {
      text_format = wasp::lsp::m_text_format_plaintext;
      insert_text = param_name + " = " + array_quote + default_value + array_quote;
    }
    // finally build full insertion from parameter name, quote, and default
 
    // add parameter label, insert text, and description to completion list
    completionItems.push_back(wasp::DataObject());
    wasp::DataObject * item = completionItems.back().to_object();
    pass &= wasp::lsp::buildCompletionObject(*item,
                                             errors,
                                             param_name,
                                             replace_line_beg,
                                             replace_char_beg,
                                             replace_line_end,
                                             replace_char_end,
                                             insert_text,
                                             complete_kind,
                                             "",
                                             doc_string,
                                             false,
                                             false,
                                             text_format);
  }
 
  return pass;
}

Referenced by gatherDocumentCompletionItems().

addResourcesForDocument()

void MooseServer::addResourcesForDocument ( )

private

Add paths from includes and FileName parameters for client to watch.

Definition at line 298 of file MooseServer.C.

{
  // return without any resources added for document if parser root is null
  auto root_ptr = queryRoot();
  if (!root_ptr)
    return;
  auto & root = *root_ptr;
 
  // return without document resources added if client does not watch files
  if (!client_watcher_support)
    return;
 
  // get input parse tree root node to be used for gathering resource files
  wasp::HITNodeView view_root = root.getNodeView();
  std::set<std::string> include_paths, filename_vals, resource_uris;
 
  // gather paths of include inputs and add to resource uris if files exist
  view_root.node_pool()->descendant_include_paths(include_paths);
  for (const auto & include_path : include_paths)
  {
    auto normalized = std::filesystem::path(include_path).lexically_normal().string();
    if (MooseUtils::checkFileReadable(normalized, false, false, false))
      resource_uris.insert(wasp::lsp::prefixUriScheme(normalized));
  }
 
  // gather paths of FileName types and add to resource uris if files exist
  getFileNameTypeValues(filename_vals, view_root);
  for (const auto & filename_val : filename_vals)
  {
    auto input_path = wasp::lsp::removeUriScheme(document_path);
    auto input_base = std::filesystem::path(input_path).parent_path();
    auto fname_path = std::filesystem::path(filename_val);
    auto fname_absl = fname_path.is_absolute() ? fname_path : (input_base / fname_path);
    auto normalized = fname_absl.lexically_normal().string();
    if (MooseUtils::checkFileReadable(normalized, false, false, false))
      resource_uris.insert(wasp::lsp::prefixUriScheme(normalized));
  }
 
  // add collection of all gathered paths as resources for current document
  setResourcesForBase(document_path, resource_uris);
}

Referenced by parseDocumentForDiagnostics().

addSubblocksToList()

bool MooseServer::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  )

private

Add subblocks to completion list for request path, line, and column.

Parameters

completionItems	- list of completion objects to be filled out
object_path	- full node path where autocomplete was requested
replace_line_beg	- start line of autocompletion replace range
replace_char_beg	- start column of autocomplete replace range
replace_line_end	- end line of autocomplete replacement range
replace_char_end	- end column of autocompletion replace range
filtering_prefix	- beginning text to filter list if not empty

Returns

- true if filling of completion items completed successfully

Definition at line 795 of file MooseServer.C.

{
  Syntax & syntax = getRegistrationApp().syntax();
 
  // set used to prevent reprocessing syntax paths for more than one action
  std::set<std::string> syntax_paths_processed;
 
  // build map of all syntax paths to names for subblocks and save to reuse
  auto & metadata = getSyntaxMetadata();
  if (metadata.syntax_to_subblocks.empty())
  {
    for (const auto & syntax_path_iter : syntax.getAssociatedActions())
    {
      std::string syntax_path = "/" + syntax_path_iter.first;
 
      // skip current syntax path if already processed for different action
      if (!syntax_paths_processed.insert(syntax_path).second)
        continue;
 
      // walk backward through syntax path adding subblock names to parents
      for (std::size_t last_sep; (last_sep = syntax_path.find_last_of("/")) != std::string::npos;)
      {
        std::string subblock_name = syntax_path.substr(last_sep + 1);
        syntax_path = syntax_path.substr(0, last_sep);
        metadata.syntax_to_subblocks[syntax_path].insert(subblock_name);
      }
    }
  }
 
  // get registered syntax from object path using map of paths to subblocks
  auto registered_syntax = syntax.isAssociated(object_path, nullptr, metadata.syntax_to_subblocks);
 
  bool pass = true;
 
  // walk over subblock names if found or at root and build completion list
  if (!registered_syntax.empty() || object_path == "/")
  {
    // choose format of insertion text based on if client supports snippets
    int text_format = client_snippet_support ? wasp::lsp::m_text_format_snippet
                                             : wasp::lsp::m_text_format_plaintext;
 
    for (const auto & subblock_name : metadata.syntax_to_subblocks[registered_syntax])
    {
      // filter subblock if it does not begin with prefix and one was given
      if (subblock_name != "*" && subblock_name.rfind(filtering_prefix, 0) != 0)
        continue;
 
      std::string doc_string;
      std::string insert_text;
      int complete_kind;
 
      // build required parameter list for each block to use in insert text
      const std::string full_block_path = object_path + "/" + subblock_name;
      const std::string req_params = getRequiredParamsText(full_block_path, "", {}, "  ");
 
      // customize description and insert text for star and named subblocks
      if (subblock_name == "*")
      {
        doc_string = "custom user named block";
        insert_text = (request_on_block_decl ? "" : "[") +
                      (filtering_prefix.size() ? filtering_prefix : "block_name") + "]" +
                      req_params + "\n  " + (client_snippet_support ? "$0" : "") + "\n[]";
        complete_kind = wasp::lsp::m_comp_kind_variable;
      }
      else
      {
        doc_string = "application named block";
        insert_text = (request_on_block_decl ? "" : "[") + subblock_name + "]" + req_params +
                      "\n  " + (client_snippet_support ? "$0" : "") + "\n[]";
        complete_kind = wasp::lsp::m_comp_kind_struct;
      }
 
      // add subblock name, insert text, and description to completion list
      completionItems.push_back(wasp::DataObject());
      wasp::DataObject * item = completionItems.back().to_object();
      pass &= wasp::lsp::buildCompletionObject(*item,
                                               errors,
                                               subblock_name,
                                               replace_line_beg,
                                               replace_char_beg,
                                               replace_line_end,
                                               replace_char_end,
                                               insert_text,
                                               complete_kind,
                                               "",
                                               doc_string,
                                               false,
                                               false,
                                               text_format);
    }
  }
 
  return pass;
}

Referenced by gatherDocumentCompletionItems().

addValuesToList()

bool MooseServer::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  )

private

Add parameter values to completion list for request line and column.

Parameters

completionItems	- list of completion objects to be filled out
valid_params	- all valid parameters used for value completion
existing_params	- set of parameters already existing in input
existing_subblocks	- active and inactive subblock name values
param_name	- name of input parameter for value autocompletion
obj_act_tasks	- tasks to verify object type with valid syntax
object_path	- full node path where autocomplete was requested
replace_line_beg	- start line of autocompletion replace range
replace_char_beg	- start column of autocomplete replace range
replace_line_end	- end line of autocomplete replacement range
replace_char_end	- end column of autocompletion replace range

Returns

- true if filling of completion items completed successfully

Definition at line 898 of file MooseServer.C.

{
  Syntax & syntax = getRegistrationApp().syntax();
  Factory & factory = getRegistrationApp().getFactory();
 
  // get clean type for path associations and basic type for boolean values
  std::string dirty_type = valid_params.type(param_name);
  std::string clean_type = MooseUtils::prettyCppType(dirty_type);
  std::string basic_type = JsonSyntaxTree::basicCppType(clean_type);
 
  // remove any array prefixes from basic type string and replace with base
  pcrecpp::RE("(Array:)*(.*)").GlobalReplace("\\2", &basic_type);
 
  // prepare clean cpp type string to be used for a key to find input paths
  pcrecpp::RE(".+<([A-Za-z0-9_' ':]*)>.*").GlobalReplace("\\1", &clean_type);
 
  // decide completion item kind that client may use to display a list icon
  int complete_kind = getCompletionItemKind(valid_params, param_name, clean_type, false);
 
  // map used to gather options and descriptions for value completion items
  std::map<std::string, std::string> options_and_descs;
 
  // first if parameter name is active or inactive then use input subblocks
  if (param_name == "active" || param_name == "inactive")
    for (const auto & subblock_name : existing_subblocks)
      options_and_descs[subblock_name] = "subblock name";
 
  // otherwise if parameter type is boolean then use true and false strings
  else if (basic_type == "Boolean")
  {
    options_and_descs["true"];
    options_and_descs["false"];
  }
 
  // otherwise if parameter type is one of the enums then use valid options
  else if (valid_params.have_parameter<MooseEnum>(param_name))
    getEnumsAndDocs(valid_params.get<MooseEnum>(param_name), options_and_descs);
  else if (valid_params.have_parameter<MultiMooseEnum>(param_name))
    getEnumsAndDocs(valid_params.get<MultiMooseEnum>(param_name), options_and_descs);
  else if (valid_params.have_parameter<ExecFlagEnum>(param_name))
    getEnumsAndDocs(valid_params.get<ExecFlagEnum>(param_name), options_and_descs);
  else if (valid_params.have_parameter<std::vector<MooseEnum>>(param_name))
    getEnumsAndDocs(valid_params.get<std::vector<MooseEnum>>(param_name)[0], options_and_descs);
 
  // otherwise if parameter is Application type then use all available apps
  else if (object_path == "/Application" && param_name == "type")
  {
    for (const auto & apps_iter : AppFactory::instance().registeredObjects())
    {
      const std::string & app_name = apps_iter.first;
      const InputParameters & app_params = apps_iter.second->buildParameters();
      std::string app_description = app_params.getClassDescription();
      MooseUtils::escape(app_description);
      options_and_descs[app_name] = app_description;
    }
  }
 
  // otherwise if parameter name is type then use all verified object names
  else if (param_name == "type")
  {
    // walk over entire set of objects that have been registered in factory
    for (const auto & objects_iter : factory.registeredObjects())
    {
      const std::string & object_name = objects_iter.first;
      const InputParameters & object_params = objects_iter.second->buildParameters();
 
      // build required parameter list for each block to use in insert text
      std::string req_params = getRequiredParamsText(object_path, object_name, existing_params, "");
      req_params += req_params.size() ? "\n" + std::string(client_snippet_support ? "$0" : "") : "";
 
      // check if object has registered base parameter that can be verified
      if (!object_params.hasBase())
        continue;
      const std::string & moose_base = object_params.getBase();
 
      // walk over gathered MooseObjectAction tasks and add if base matches
      for (const auto & obj_act_task : obj_act_tasks)
      {
        if (!syntax.verifyMooseObjectTask(moose_base, obj_act_task))
          continue;
        std::string type_description = object_params.getClassDescription();
        MooseUtils::escape(type_description);
        options_and_descs[object_name + req_params] = type_description;
        break;
      }
    }
  }
 
  // otherwise if parameter type has any associated syntax then use lookups
  else
  {
    // build map of parameter types to input lookup paths and save to reuse
    auto & metadata = getSyntaxMetadata();
    if (metadata.type_to_input_paths.empty())
    {
      for (const auto & associated_types_iter : syntax.getAssociatedTypes())
      {
        const std::string & type = associated_types_iter.second;
        const std::string & path = associated_types_iter.first;
        metadata.type_to_input_paths[type].insert(path);
      }
    }
 
    // check for input lookup paths that are associated with parameter type
    const auto & input_path_iter = metadata.type_to_input_paths.find(clean_type);
 
    if (input_path_iter != metadata.type_to_input_paths.end())
    {
      wasp::HITNodeView view_root = getRoot().getNodeView();
 
      // walk over all syntax paths that are associated with parameter type
      for (const auto & input_path : input_path_iter->second)
      {
        // use wasp siren to gather all input values at current lookup path
        wasp::SIRENInterpreter<> selector;
        if (!selector.parseString(input_path))
          continue;
        wasp::SIRENResultSet<wasp::HITNodeView> results;
        std::size_t count = selector.evaluate(view_root, results);
 
        // walk over results and add each input value found at current path
        for (std::size_t i = 0; i < count; i++)
          if (results.adapted(i).type() == wasp::OBJECT)
            options_and_descs[results.adapted(i).name()] = "from /" + input_path;
      }
    }
 
    // warehouse based completion is unavailable if problem failed to build
    // input lookup based completion works even when problem fails to build
    // so warehouse completion supplements lookups rather than replacing it
    addObjectsFromWarehouses(clean_type, options_and_descs);
  }
 
  // choose format of insertion text based on if client has snippet support
  int text_format = client_snippet_support ? wasp::lsp::m_text_format_snippet
                                           : wasp::lsp::m_text_format_plaintext;
 
  bool pass = true;
 
  // walk over pairs of options with descriptions and build completion list
  for (const auto & option_and_desc : options_and_descs)
  {
    const std::string & insert_text = option_and_desc.first;
    const std::string & option_name = insert_text.substr(0, insert_text.find('\n'));
    const std::string & description = option_and_desc.second;
 
    // add option name, insertion range, and description to completion list
    completionItems.push_back(wasp::DataObject());
    wasp::DataObject * item = completionItems.back().to_object();
    pass &= wasp::lsp::buildCompletionObject(*item,
                                             errors,
                                             option_name,
                                             replace_line_beg,
                                             replace_char_beg,
                                             replace_line_end,
                                             replace_char_end,
                                             insert_text,
                                             complete_kind,
                                             "",
                                             description,
                                             false,
                                             false,
                                             text_format);
  }
 
  return pass;
}

Referenced by gatherDocumentCompletionItems().

buildDistPlotResponses()

void MooseServer::buildDistPlotResponses ( wasp::DataArray &  plotting_responses, FEProblemBase &  problem, const std::string &  object_name, const std::string &  object_type  )

private

Compute PDF and CDF, build CustomPlot objects, and add to responses.

Parameters

plotting_responses	- array to be filled by CustomPlot objects
problem	- problem to query warehouses when building plot data
object_name	- name of request object to use for problem query
object_type	- type of request object to use in title for plot

Definition at line 1985 of file MooseServer.C.

{
  // get distribution from problem that is registered for given object name
  const Distribution & dist = problem.getDistribution(object_name);
 
  // pick plot x-range using quantiles to be generic for distribution types
  const double min_x = dist.quantile(_dist_plot_quantile_bound);
  const double max_x = dist.quantile(1.0 - _dist_plot_quantile_bound);
  const double del_x = (max_x - min_x) / (_dist_plot_num_points - 1);
 
  // return without any plots added if any calculated values are not finite
  if (!std::isfinite(min_x) || !std::isfinite(max_x) || max_x <= min_x || !std::isfinite(del_x))
    return;
 
  // use uniform grid of x-axis graph keys to sample plot values for y-axis
  std::vector<double> graph_keys(_dist_plot_num_points);
  std::vector<double> pdf_values(_dist_plot_num_points);
  std::vector<double> cdf_values(_dist_plot_num_points);
 
  // calculate PDF values and CDF values for each key within range of graph
  for (std::size_t i = 0; i < _dist_plot_num_points; i++)
  {
    graph_keys[i] = min_x + (i * del_x);
    pdf_values[i] = dist.pdf(graph_keys[i]);
    cdf_values[i] = dist.cdf(graph_keys[i]);
 
    // return without any plots added if any PDF or CDF value is not finite
    if (!std::isfinite(pdf_values[i]) || !std::isfinite(cdf_values[i]))
      return;
  }
 
  // lambda to build CustomPlot object for distribution and add to response
  auto add_dist_to_plot = [&](const std::string & dist_type, const std::vector<double> & graph_vals)
  {
    std::string plot_title = object_name + " " + object_type + " " + dist_type + " Distribution";
    std::string x_axis_label = "x values";
    std::string y_axis_label = dist_type + " values";
    wasp::CustomPlot plot_object;
    buildLineGraphPlot(plot_object, plot_title, x_axis_label, y_axis_label, graph_keys, graph_vals);
    plotting_responses.push_back(wasp::serializeCustomPlot(plot_object));
  };
 
  // build CustomPlot object for PDF values, serialize, and add to response
  add_dist_to_plot("PDF", pdf_values);
 
  // build CustomPlot object for CDF values, serialize, and add to response
  add_dist_to_plot("CDF", cdf_values);
}

Referenced by gatherPlottingResponses().

buildFuncPlotResponse()

void MooseServer::buildFuncPlotResponse ( wasp::DataArray &  plotting_responses, FEProblemBase &  problem, const std::string &  object_name, const std::string &  object_type  )

private

Gather function data, build CustomPlot object, and add to responses.

Parameters

plotting_responses	- array to be filled by CustomPlot objects
problem	- problem to query warehouses when building plot data
object_name	- name of request object to use for problem query
object_type	- type of request object to use in title for plot

Definition at line 1953 of file MooseServer.C.

{
  // get function from problem and return with no plots added if wrong type
  const auto * pw_func = dynamic_cast<const PiecewiseBase *>(&problem.getFunction(object_name));
  if (!pw_func)
    return;
 
  // return without adding plot response objects when function size is zero
  if (pw_func->functionSize() == 0)
    return;
 
  // walk over piecewise function and gather keys and values for line graph
  std::vector<double> graph_keys, graph_vals;
  for (std::size_t i = 0; i < pw_func->functionSize(); i++)
  {
    graph_keys.push_back(pw_func->domain(i));
    graph_vals.push_back(pw_func->range(i));
  }
 
  // build CustomPlot object from function data then serialize for response
  std::string plot_title = object_name + " " + object_type + " Function";
  std::string x_axis_label = "abscissa values";
  std::string y_axis_label = "ordinate values";
  wasp::CustomPlot plot_object;
  buildLineGraphPlot(plot_object, plot_title, x_axis_label, y_axis_label, graph_keys, graph_vals);
  plotting_responses.push_back(wasp::serializeCustomPlot(plot_object));
}

Referenced by gatherPlottingResponses().

buildLineGraphPlot()

void MooseServer::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  )

private

Build CustomPlot graph with provided keys, values, and plot title.

Parameters

plot_object	- CustomPlot object to be built into line graph
plot_title	- title for plot composed of block name and type
x_axis_label	- label for x-axis of plot dependent upon type
y_axis_label	- label for y-axis of plot dependent upon type
graph_keys	- x values of function or distribution for graph
graph_vals	- y values of function or distribution for graph

Definition at line 2038 of file MooseServer.C.

{
  // axis ranges
  double min_key = *std::min_element(graph_keys.begin(), graph_keys.end());
  double max_key = *std::max_element(graph_keys.begin(), graph_keys.end());
  double min_val = *std::min_element(graph_vals.begin(), graph_vals.end());
  double max_val = *std::max_element(graph_vals.begin(), graph_vals.end());
 
  // widen extents
  double pad_factor = 0.05;
  double pad_x_axis = (max_key - min_key) * pad_factor;
  double pad_y_axis = (max_val - min_val) * pad_factor;
  if (pad_y_axis == 0)
    pad_y_axis = pad_factor;
  min_key -= pad_x_axis;
  max_key += pad_x_axis;
  min_val -= pad_y_axis;
  max_val += pad_y_axis;
 
  // plot setup
  plot_object.title().text(plot_title);
  plot_object.title().font().pointsize(18);
  plot_object.title().visible(true);
  plot_object.legend().visible(false);
 
  // plot x-axis
  plot_object.x1Axis().label(x_axis_label);
  plot_object.x1Axis().rangeMin(min_key);
  plot_object.x1Axis().rangeMax(max_key);
  plot_object.x1Axis().scaleType(wasp::CustomPlot::stLinear);
  plot_object.x1Axis().labelType(wasp::CustomPlot::ltNumber);
  plot_object.x1Axis().labelFont().pointsize(18);
  plot_object.x1Axis().tickLabelFont().pointsize(16);
 
  // plot y-axis
  plot_object.y1Axis().label(y_axis_label);
  plot_object.y1Axis().rangeMin(min_val);
  plot_object.y1Axis().rangeMax(max_val);
  plot_object.y1Axis().scaleType(wasp::CustomPlot::stLinear);
  plot_object.y1Axis().labelType(wasp::CustomPlot::ltNumber);
  plot_object.y1Axis().labelFont().pointsize(18);
  plot_object.y1Axis().tickLabelFont().pointsize(16);
 
  // graph series
  auto line_graph = std::make_shared<wasp::CustomPlot::Graph>();
  line_graph->keys() = graph_keys;
  line_graph->values() = graph_vals;
  line_graph->scatterShape(wasp::CustomPlot::ssDisc);
  plot_object.series().push_back(line_graph);
}

Referenced by buildDistPlotResponses(), and buildFuncPlotResponse().

connectionRead()

bool MooseServer::connectionRead ( wasp::DataObject &  object )

inlineprivate

Read from connection into object - specific to this server's connection.

Parameters

object

- reference to object to be read into

Returns

- true if the read from the connection completed successfully

Definition at line 421 of file MooseServer.h.

{ return _connection->read(object, errors); }

connectionWrite()

bool MooseServer::connectionWrite ( wasp::DataObject &  object )

inlineprivate

Write object json to connection - specific to this server's connection.

Parameters

object

- reference to object with contents to write to connection

Returns

- true if the write to the connection completed successfully

Definition at line 428 of file MooseServer.h.

{ return _connection->write(object, errors); }

formatDocument()

std::string MooseServer::formatDocument ( wasp::HITNodeView  parent, std::size_t &  prev_line, std::size_t  level  )

private

Recursively walk down whole nodeview tree while formatting document.

Parameters

parent	- nodeview for recursive tree traversal starting point
prev_line	- line of last print for blanks and inline comments
level	- current level in document tree to use for indentation

Returns

- formatted string that gets appended to each recursive call

Definition at line 1622 of file MooseServer.C.

{
  // build string of newline and indentation spaces from level and tab size
  std::string newline_indent = "\n" + std::string(level * _formatting_tab_size, ' ');
 
  // lambda to format include data by replacing consecutive spaces with one
  auto collapse_spaces = [](std::string string_copy)
  {
    pcrecpp::RE("\\s+").Replace(" ", &string_copy);
    return string_copy;
  };
 
  // formatted string that will be built recursively by appending each call
  std::string format_string;
 
  // walk over all children of this node context and build formatted string
  for (const auto i : make_range(parent.child_count()))
  {
    // walk must be index based to catch file include and skip its children
    wasp::HITNodeView child = parent.child_at(i);
 
    // get declarator to address shorthand syntax object with no declarator
    auto decl = child.child_count_by_name("decl") ? child.first_child_by_name("decl").data() : "";
 
    // add blank line if necessary after previous line and before this line
    std::string blank = child.line() > prev_line + 1 ? "\n" : "";
 
    // format include directive with indentation and collapse extra spacing
    if (child.type() == wasp::FILE)
      format_string += blank + newline_indent + MooseUtils::trim(collapse_spaces(child.data()));
 
    // format normal comment with indentation and inline comment with space
    else if (child.type() == wasp::COMMENT)
      format_string += (child.line() == prev_line ? " " : blank + newline_indent) +
                       MooseUtils::trim(child.data());
 
    // pass object with no declarator through without increased indentation
    else if (child.type() == wasp::OBJECT && decl.empty())
      format_string += formatDocument(child, prev_line, level);
 
    // format object recursively with indentation and without legacy syntax
    else if (child.type() == wasp::OBJECT)
      format_string += blank + newline_indent + "[" + decl + "]" +
                       formatDocument(child, prev_line, level + 1) + newline_indent + "[]";
 
    // format keyed value with indentation and calling reusable hit methods
    else if (child.type() == wasp::KEYED_VALUE || child.type() == wasp::ARRAY)
    {
      const std::string assign = wasp::is_override(child) ? child.child_at(1).data() : "=";
      const std::string prefix = newline_indent + decl + " " + assign + " ";
 
      const std::string render_val = hit::extractValue(child.data());
      std::size_t val_column = child.child_count() > 2 ? child.child_at(2).column() : 0;
      std::size_t prefix_len = prefix.size() - 1;
 
      format_string += blank + prefix + hit::formatValue(render_val, val_column, prefix_len);
    }
 
    // set previous line reference used for blank lines and inline comments
    prev_line = child.last_line();
  }
 
  // return formatted text string that gets appended to each recursive call
  return format_string;
}

Referenced by formatDocument(), and gatherDocumentFormattingTextEdits().

gatherDocumentCompletionItems()

bool MooseServer::gatherDocumentCompletionItems ( wasp::DataArray &  completionItems, bool &  is_incomplete, int  line, int  character  )

private

Gather document completion items - specific to this server implemention.

Parameters

completionItems	- data array of completion item objects to fill
is_incomplete	- flag indicating if the completions are complete
line	- line to be used for completions gathering logic
character	- column to be used for completions gathering logic

Returns

- true if the gathering of items completed successfully

Definition at line 397 of file MooseServer.C.

{
  auto root_ptr = queryRoot();
 
  // add only root level blocks to completion list when parser root is null
  if (!root_ptr)
    return addSubblocksToList(completionItems, "/", line, character, line, character, "", false);
  auto & root = *root_ptr;
 
  // lambdas that will be used for checking completion request context type
  auto is_request_in_open_block = [](wasp::HITNodeView request_context)
  {
    return request_context.type() == wasp::OBJECT || request_context.type() == wasp::DOCUMENT_ROOT;
  };
  auto is_request_on_param_decl = [](wasp::HITNodeView request_context)
  {
    return request_context.type() == wasp::DECL && request_context.has_parent() &&
           (request_context.parent().type() == wasp::KEYED_VALUE ||
            request_context.parent().type() == wasp::ARRAY);
  };
  auto is_request_on_block_decl = [](wasp::HITNodeView request_context)
  {
    return request_context.type() == wasp::DECL && request_context.has_parent() &&
           request_context.parent().type() == wasp::OBJECT;
  };
 
  // get document tree root used to find node under request line and column
  wasp::HITNodeView view_root = root.getNodeView();
  wasp::HITNodeView request_context;
 
  // find node under request location if it is not past all defined content
  if (line + 1 < (int)view_root.last_line() ||
      (line + 1 == (int)view_root.last_line() && character <= (int)view_root.last_column()))
    request_context = wasp::findNodeUnderLineColumn(view_root, line + 1, character + 1);
 
  // otherwise find last node in document with last line and column of tree
  else
  {
    request_context =
        wasp::findNodeUnderLineColumn(view_root, view_root.last_line(), view_root.last_column());
 
    // change context to be parent block or grandparent if block terminator
    wasp::HITNodeView object_context = request_context;
    while (object_context.type() != wasp::OBJECT && object_context.has_parent())
      object_context = object_context.parent();
    if (request_context.type() == wasp::OBJECT_TERM && object_context.has_parent())
      object_context = object_context.parent();
    request_context = object_context;
  }
 
  // change context to equal sign if it is preceding node and in open block
  if (is_request_in_open_block(request_context))
  {
    wasp::HITNodeView backup_context = request_context;
    for (int backup_char = character; backup_context == request_context && --backup_char > 0;)
      backup_context = wasp::findNodeUnderLineColumn(request_context, line + 1, backup_char + 1);
    if (backup_context.type() == wasp::ASSIGN || backup_context.type() == wasp::OVERRIDE_ASSIGN)
      request_context = backup_context;
  }
 
  // use request context type to set up replacement range and prefix filter
  int replace_line_beg = line;
  int replace_char_beg = character;
  int replace_line_end = line;
  int replace_char_end = character;
  std::string filtering_prefix;
  if (request_context.type() == wasp::DECL || request_context.type() == wasp::VALUE)
  {
    // completion on existing block name, parameter name, or value replaces
    replace_line_beg = request_context.line() - 1;
    replace_char_beg = request_context.column() - 1;
    replace_line_end = request_context.last_line() - 1;
    replace_char_end = request_context.last_column();
    filtering_prefix = request_context.data();
 
    // empty block name columns are same as bracket so bump replace columns
    if (is_request_on_block_decl(request_context) && filtering_prefix.empty())
    {
      replace_char_beg++;
      replace_char_end++;
    }
  }
 
  // get name of request context direct parent node so it can be used later
  const auto & parent_name = request_context.has_parent() ? request_context.parent().name() : "";
 
  // get object context and value of type parameter for request if provided
  wasp::HITNodeView object_context = request_context;
  while (object_context.type() != wasp::OBJECT && object_context.has_parent())
    object_context = object_context.parent();
  if (is_request_on_block_decl(request_context))
    object_context = object_context.parent();
  const std::string & object_path = object_context.path();
  wasp::HITNodeView type_node = object_context.first_child_by_name("type");
  const std::string & object_type =
      type_node.is_null() ? "" : wasp::strip_quotes(hit::extractValue(type_node.data()));
 
  // get set of all parameter and subblock names already specified in input
  std::set<std::string> existing_params, existing_subblocks;
  getExistingInput(object_context, existing_params, existing_subblocks);
 
  // set used to gather all parameters valid from object context of request
  InputParameters valid_params = emptyInputParameters();
 
  // set used to gather MooseObjectAction tasks to verify object parameters
  std::set<std::string> obj_act_tasks;
 
  // get set of global parameters, action parameters, and object parameters
  getAllValidParameters(valid_params, object_path, object_type, obj_act_tasks);
 
  bool pass = true;
 
  // add gathered parameters to completion list with input range and prefix
  if (is_request_in_open_block(request_context) || is_request_on_param_decl(request_context))
    pass &= addParametersToList(completionItems,
                                valid_params,
                                existing_params,
                                replace_line_beg,
                                replace_char_beg,
                                replace_line_end,
                                replace_char_end,
                                filtering_prefix);
 
  // add all valid subblocks to completion list with input range and prefix
  if (is_request_in_open_block(request_context) || is_request_on_param_decl(request_context) ||
      is_request_on_block_decl(request_context))
    pass &= addSubblocksToList(completionItems,
                               object_path,
                               replace_line_beg,
                               replace_char_beg,
                               replace_line_end,
                               replace_char_end,
                               filtering_prefix,
                               is_request_on_block_decl(request_context));
 
  // add valid parameter value options to completion list using input range
  if ((request_context.type() == wasp::VALUE || request_context.type() == wasp::ASSIGN ||
       request_context.type() == wasp::OVERRIDE_ASSIGN) &&
      valid_params.getParametersList().count(parent_name))
    pass &= addValuesToList(completionItems,
                            valid_params,
                            existing_params,
                            existing_subblocks,
                            parent_name,
                            obj_act_tasks,
                            object_path,
                            replace_line_beg,
                            replace_char_beg,
                            replace_line_end,
                            replace_char_end);
 
  is_incomplete = !pass;
 
  return pass;
}

gatherDocumentDefinitionLocations()

bool MooseServer::gatherDocumentDefinitionLocations ( wasp::DataArray &  definitionLocations, int  line, int  character  )

private

Gather definition locations - specific to this server implemention.

Parameters

definitionLocations	- data array of locations objects to fill
line	- line to be used for locations gathering logic
character	- column to be used for locations gathering logic

Returns

- true if the gathering of locations completed successfully

Definition at line 1161 of file MooseServer.C.

{
  Factory & factory = getRegistrationApp().getFactory();
 
  // return without any definition locations added when parser root is null
  auto root_ptr = queryRoot();
  if (!root_ptr)
    return true;
  auto & root = *root_ptr;
 
  // find hit node for zero based request line and column number from input
  wasp::HITNodeView view_root = root.getNodeView();
  wasp::HITNodeView request_context =
      wasp::findNodeUnderLineColumn(view_root, line + 1, character + 1);
 
  // return without any definition locations added when node not value type
  if (request_context.type() != wasp::VALUE)
    return true;
 
  // get name of parameter node parent of value and value string from input
  std::string param_name = request_context.has_parent() ? request_context.parent().name() : "";
  std::string val_string = request_context.last_as_string();
 
  // add source code location if type parameter with registered object name
  if (param_name == "type" && factory.isRegistered(val_string))
  {
    // get file path and line number of source code registering object type
    FileLineInfo file_line_info = factory.getLineInfo(val_string);
 
    // return without any definition locations added if file cannot be read
    if (!file_line_info.isValid() ||
        !MooseUtils::checkFileReadable(file_line_info.file(), false, false, false))
      return true;
 
    // add file scheme prefix to front of file path to build definition uri
    auto location_uri = wasp::lsp::m_uri_prefix + file_line_info.file();
 
    // add file uri and zero based line and column range to definition list
    definitionLocations.push_back(wasp::DataObject());
    wasp::DataObject * location = definitionLocations.back().to_object();
    return wasp::lsp::buildLocationObject(*location,
                                          errors,
                                          location_uri,
                                          file_line_info.line() - 1,
                                          0,
                                          file_line_info.line() - 1,
                                          1000);
  }
 
  // get object context and value of type parameter for request if provided
  wasp::HITNodeView object_context = request_context;
  while (object_context.type() != wasp::OBJECT && object_context.has_parent())
    object_context = object_context.parent();
  const std::string & object_path = object_context.path();
  wasp::HITNodeView type_node = object_context.first_child_by_name("type");
  const std::string & object_type =
      type_node.is_null() ? "" : wasp::strip_quotes(hit::extractValue(type_node.data()));
 
  // set used to gather all parameters valid from object context of request
  InputParameters valid_params = emptyInputParameters();
 
  // set used to gather MooseObjectAction tasks to verify object parameters
  std::set<std::string> obj_act_tasks;
 
  // get set of global parameters, action parameters, and object parameters
  getAllValidParameters(valid_params, object_path, object_type, obj_act_tasks);
 
  // set used to gather nodes from input lookups custom sorted by locations
  SortedLocationNodes location_nodes(
      [](const wasp::HITNodeView & l, const wasp::HITNodeView & r)
      {
        const std::string & l_file = l.node_pool()->stream_name();
        const std::string & r_file = r.node_pool()->stream_name();
        return (l_file < r_file || (l_file == r_file && l.line() < r.line()) ||
                (l_file == r_file && l.line() == r.line() && l.column() < r.column()));
      });
 
  // gather all lookup path nodes matching value if parameter name is valid
  for (const auto & valid_params_iter : valid_params)
  {
    if (valid_params_iter.first == param_name)
    {
      // get cpp type and prepare string for use as key finding input paths
      std::string dirty_type = valid_params.type(param_name);
      std::string clean_type = MooseUtils::prettyCppType(dirty_type);
      pcrecpp::RE(".+<([A-Za-z0-9_' ':]*)>.*").GlobalReplace("\\1", &clean_type);
 
      // get set of nodes from associated path lookups matching input value
      getInputLookupDefinitionNodes(location_nodes, clean_type, val_string);
      break;
    }
  }
 
  // add parameter declarator to set if none were gathered by input lookups
  if (location_nodes.empty() && request_context.has_parent() &&
      request_context.parent().child_count_by_name("decl"))
    location_nodes.insert(request_context.parent().first_child_by_name("decl"));
 
  // add locations to definition list using lookups or parameter declarator
  return addLocationNodesToList(definitionLocations, location_nodes);
}

gatherDocumentFormattingTextEdits()

bool MooseServer::gatherDocumentFormattingTextEdits ( wasp::DataArray &  formattingTextEdits, int  tab_size, bool  insert_spaces  )

private

Gather formatting text edits - specific to this server implemention.

Parameters

formattingTextEdits	- data array of text edit objects to fill
tab_size	- value of the size of a tab in spaces for formatting
insert_spaces	- flag indicating whether to use spaces for tabs

Returns

- true if the gathering of text edits completed successfully

Definition at line 1573 of file MooseServer.C.

{
  // strip scheme prefix from document uri if it exists for parse file path
  std::string parse_file_path = document_path;
  pcrecpp::RE("(.*://)(.*)").Replace("\\2", &parse_file_path);
 
  // input check expanded any brace expressions in cached tree so reprocess
  std::stringstream input_errors, input_stream(getDocumentText());
  wasp::DefaultHITInterpreter interpreter(input_errors);
 
  // return without adding any formatting text edits if input parsing fails
  if (!interpreter.parseStream(input_stream, parse_file_path))
    return true;
 
  // return without adding any formatting text edits if parser root is null
  if (interpreter.root().is_null())
    return true;
 
  // get input root node line and column range to represent entire document
  wasp::HITNodeView view_root = interpreter.root();
  int document_start_line = view_root.line() - 1;
  int document_start_char = view_root.column() - 1;
  int document_last_line = view_root.last_line() - 1;
  int document_last_char = view_root.last_column();
 
  // set number of spaces for indentation and build formatted document text
  _formatting_tab_size = tab_size;
  std::size_t starting_line = view_root.line() - 1;
  std::string document_format = formatDocument(view_root, starting_line, 0);
 
  // remove beginning newline character from formatted document text string
  document_format.erase(0, 1);
 
  // add formatted text with whole line and column range to formatting list
  formattingTextEdits.push_back(wasp::DataObject());
  wasp::DataObject * item = formattingTextEdits.back().to_object();
  bool pass = wasp::lsp::buildTextEditObject(*item,
                                             errors,
                                             document_start_line,
                                             document_start_char,
                                             document_last_line,
                                             document_last_char,
                                             document_format);
  return pass;
}

gatherDocumentReferencesLocations()

bool MooseServer::gatherDocumentReferencesLocations ( wasp::DataArray &  referencesLocations, int  line, int  character, bool  include_declaration  )

private

Gather references locations - specific to this server implemention.

Parameters

referencesLocations	- data array of locations objects to fill
line	- line to be used for locations gathering logic
character	- column to be used for locations gathering logic
include_declaration	- flag indicating declaration inclusion

Returns

- true if the gathering of locations completed successfully

Definition at line 1453 of file MooseServer.C.

{
  Syntax & syntax = getRegistrationApp().syntax();
 
  // return without adding any reference locations when parser root is null
  auto root_ptr = queryRoot();
  if (!root_ptr)
    return true;
  auto & root = *root_ptr;
 
  // find hit node for zero based request line and column number from input
  wasp::HITNodeView view_root = root.getNodeView();
  wasp::HITNodeView request_context =
      wasp::findNodeUnderLineColumn(view_root, line + 1, character + 1);
 
  // return without adding any references when request not block declarator
  if ((request_context.type() != wasp::DECL && request_context.type() != wasp::DOT_SLASH &&
       request_context.type() != wasp::LBRACKET && request_context.type() != wasp::RBRACKET) ||
      !request_context.has_parent() || request_context.parent().type() != wasp::OBJECT)
    return true;
 
  // get input path and block name of declarator located at request context
  const std::string & inp_path = request_context.parent().path();
  const std::string & inp_name = request_context.parent().name();
 
  // build map from input lookup paths to parameter types and save to reuse
  auto & metadata = getSyntaxMetadata();
  if (metadata.input_path_to_types.empty())
    for (const auto & associated_types_iter : syntax.getAssociatedTypes())
    {
      const std::string & path = associated_types_iter.first;
      const std::string & type = associated_types_iter.second;
      metadata.input_path_to_types[path].insert(type);
    }
 
  // get registered syntax from block path with map of input paths to types
  bool is_parent;
  auto registered_syntax = syntax.isAssociated(inp_path, &is_parent, metadata.input_path_to_types);
 
  // return without adding any references if syntax has no types associated
  if (is_parent || !metadata.input_path_to_types.count(registered_syntax))
    return true;
 
  // get set of parameter types which are associated with registered syntax
  const std::set<std::string> & target_types = metadata.input_path_to_types.at(registered_syntax);
 
  // set used to gather nodes collected by value custom sorted by locations
  SortedLocationNodes match_nodes(
      [](const wasp::HITNodeView & l, const wasp::HITNodeView & r)
      {
        const std::string & l_file = l.node_pool()->stream_name();
        const std::string & r_file = r.node_pool()->stream_name();
        return (l_file < r_file || (l_file == r_file && l.line() < r.line()) ||
                (l_file == r_file && l.line() == r.line() && l.column() < r.column()));
      });
 
  // walk input recursively and gather all nodes that match value and types
  getNodesByValueAndTypes(match_nodes, view_root, inp_name, target_types);
 
  // return without adding any references if no nodes match value and types
  if (match_nodes.empty())
    return true;
 
  // add request context node to set if declaration inclusion was specified
  if (include_declaration && request_context.parent().child_count_by_name("decl"))
    match_nodes.insert(request_context.parent().first_child_by_name("decl"));
 
  // add locations to references list with nodes that match value and types
  return addLocationNodesToList(referencesLocations, match_nodes);
}

gatherDocumentSymbols()

bool MooseServer::gatherDocumentSymbols ( wasp::DataArray &  documentSymbols )

private

Gather document symbols - specific to this server implemention.

Parameters

documentSymbols

- data array of symbols data objects to fill

Returns

- true if the gathering of symbols completed successfully

Definition at line 1689 of file MooseServer.C.

{
  // return prior to starting document symbol tree when parser root is null
  auto root_ptr = queryRoot();
  if (!root_ptr)
    return true;
  auto & root = *root_ptr;
 
  wasp::HITNodeView view_root = root.getNodeView();
 
  bool pass = true;
 
  // walk over all children of root node context and build document symbols
  for (const auto i : make_range(view_root.child_count()))
  {
    // walk must be index based to catch file include and skip its children
    wasp::HITNodeView view_child = view_root.child_at(i);
 
    // set up name, zero based line and column range, kind, and detail info
    std::string name = view_child.name();
    int line = view_child.line() - 1;
    int column = view_child.column() - 1;
    int last_line = view_child.last_line() - 1;
    int last_column = view_child.last_column();
    int symbol_kind = getDocumentSymbolKind(view_child);
    std::string detail =
        !view_child.first_child_by_name("type").is_null()
            ? wasp::strip_quotes(hit::extractValue(view_child.first_child_by_name("type").data()))
            : "";
 
    // build document symbol object from node child info and push to array
    documentSymbols.push_back(wasp::DataObject());
    wasp::DataObject * data_child = documentSymbols.back().to_object();
    pass &= wasp::lsp::buildDocumentSymbolObject(*data_child,
                                                 errors,
                                                 (name.empty() ? "void" : name),
                                                 detail,
                                                 symbol_kind,
                                                 false,
                                                 line,
                                                 column,
                                                 last_line,
                                                 last_column,
                                                 line,
                                                 column,
                                                 last_line,
                                                 last_column);
 
    // call method to recursively fill document symbols for each node child
    pass &= traverseParseTreeAndFillSymbols(view_child, *data_child);
  }
 
  return pass;
}

gatherExtensionResponses()

bool MooseServer::gatherExtensionResponses ( wasp::DataArray &  extensionResponses, const std::string &  extensionMethod, int  line, int  character  )

private

Gather extension responses - specific to this server implemention.

Parameters

extensionResponses	- data array of custom responses to fill
extensionMethod	- name for current extension request method
line	- zero-based line to use for logic of custom extension
character	- zero-based column for logic of custom extension

Returns

- true if request successfully handled with response built

Definition at line 1896 of file MooseServer.C.

{
  // use appropriate method to fill response based on extension method name
  bool pass = true;
  if (extensionMethod == "plotting")
    pass = gatherPlottingResponses(extensionResponses, line, character);
  return pass;
}

gatherPlottingResponses()

bool MooseServer::gatherPlottingResponses ( wasp::DataArray &  plotting_responses, int  line, int  character  )

private

Build CustomPlot extension responses when method name is plotting.

Parameters

plotting_responses	- array for CustomPlot responses to fill
line	- zero-based line to use for logic of custom extension
character	- zero-based column for logic of custom extension

Returns

- true if request successfully handled with response built

Definition at line 1909 of file MooseServer.C.

{
  // return without adding any plot response objects if parser root is null
  auto root_ptr = queryRoot();
  if (!root_ptr)
    return true;
  auto & root = *root_ptr;
 
  // find hit node for zero based request line and column number from input
  wasp::HITNodeView view_root = root.getNodeView();
  wasp::HITNodeView request_context =
      wasp::findNodeUnderLineColumn(view_root, line + 1, character + 1);
 
  // get object context and value of type parameter for request if provided
  wasp::HITNodeView object_context = request_context;
  while (object_context.type() != wasp::OBJECT && object_context.has_parent())
    object_context = object_context.parent();
  const std::string & object_name = object_context.name();
  wasp::HITNodeView type_node = object_context.first_child_by_name("type");
  const std::string & object_type =
      type_node.is_null() ? "" : wasp::strip_quotes(hit::extractValue(type_node.data()));
 
  // get check app of document and return with no plots if its build failed
  auto app_ptr = queryCheckApp();
  if (!app_ptr)
    return true;
 
  // get problem from action warehouse and return without any plots if null
  std::shared_ptr<FEProblemBase> & problem = app_ptr->actionWarehouse().problemBase();
  if (!problem)
    return true;
 
  // check problem to build function plot if request is from function block
  if (problem->hasFunction(object_name))
    buildFuncPlotResponse(plotting_responses, *problem, object_name, object_type);
 
  // check problem to build PDF and CDF plots if request is in distribution
  else if (problem->hasDistribution(object_name))
    buildDistPlotResponses(plotting_responses, *problem, object_name, object_type);
 
  return true;
}

Referenced by gatherExtensionResponses().

getActionParameters()

void MooseServer::getActionParameters ( InputParameters &  valid_params, const std::string &  object_path, std::set< std::string > &  obj_act_tasks  )

private

Get all action parameters using requested object path to collection.

Parameters

valid_params	- collection for filling action input parameters
object_path	- full node path where autocomplete was requested
obj_act_tasks	- set for adding in all MooseObjectAction tasks

Definition at line 587 of file MooseServer.C.

{
  Syntax & syntax = getRegistrationApp().syntax();
  ActionFactory & action_factory = getRegistrationApp().getActionFactory();
 
  // get registered syntax path identifier using actual object context path
  bool is_parent;
  std::string registered_syntax = syntax.isAssociated(object_path, &is_parent);
 
  // use is_parent to skip action parameters when not explicitly registered
  if (!is_parent)
  {
    // get action objects associated with registered syntax path identifier
    auto action_range = syntax.getActions(registered_syntax);
 
    // traverse action objects for syntax to gather valid action parameters
    for (auto action_iter = action_range.first; action_iter != action_range.second; action_iter++)
    {
      const std::string & action_name = action_iter->second._action;
 
      // use action name to get set of valid parameters from action factory
      InputParameters action_params = action_factory.getValidParams(action_name);
 
      // gather all MooseObjectAction tasks for verifying object parameters
      if (action_params.have_parameter<bool>("isObjectAction"))
      {
        if (action_params.get<bool>("isObjectAction"))
        {
          std::set<std::string> tasks_by_actions = action_factory.getTasksByAction(action_name);
          obj_act_tasks.insert(tasks_by_actions.begin(), tasks_by_actions.end());
        }
 
        // filter parameter from completion list as it is not used in input
        action_params.remove("isObjectAction");
      }
 
      // add parameters from action to full valid collection being gathered
      valid_params += action_params;
    }
  }
}

Referenced by getAllValidParameters().

getAllValidParameters()

void MooseServer::getAllValidParameters ( InputParameters &  valid_params, const std::string &  object_path, const std::string &  object_type, std::set< std::string > &  obj_act_tasks  )

private

Get all global parameters, action parameters, and object parameters.

Parameters

valid_params	- collection to fill with valid input parameters
object_path	- full node path where autocomplete was requested
object_type	- type of object where autocomplete was requested
obj_act_tasks	- set for adding in all MooseObjectAction tasks

Definition at line 575 of file MooseServer.C.

{
  // gather global parameters then action parameters then object parameters
  valid_params += Moose::Builder::validParams();
  getActionParameters(valid_params, object_path, obj_act_tasks);
  getObjectParameters(valid_params, object_type, obj_act_tasks);
}

Referenced by gatherDocumentCompletionItems(), gatherDocumentDefinitionLocations(), getFileNameTypeValues(), getHoverDisplayText(), getNodesByValueAndTypes(), and getRequiredParamsText().

getCheckApp()

MooseApp & MooseServer::getCheckApp

(

)

Public interface for writable check app reference with error checks.

Returns

- writable reference to check app for current input document

Definition at line 2151 of file MooseServer.C.

{
  if (auto app_ptr = queryCheckApp())
  {
    auto & app = *app_ptr;
    mooseAssert(queryCheckParser(), "Should have a parser");
    mooseAssert(&app.parser() == queryCheckParser(), "Parser should be the app's parser");
    return app;
  }
  mooseError("MooseServer::getCheckApp(): App not available");
}

Referenced by parseDocumentForDiagnostics().

getCompletionItemKind()

int MooseServer::getCompletionItemKind ( const InputParameters &  valid_params, const std::string &  param_name, const std::string &  clean_type, bool  is_param  )

private

Get completion item kind value that client may use for icon in list.

Parameters

valid_params	- valid parameters used for completion item kind
param_name	- name of input parameter for completion item kind
clean_type	- type to decide if reference completion item kind
is_param	- boolean denoting if kind is for parameter or value

Returns

- enumerated kind value that client may use for icon in list

Definition at line 1797 of file MooseServer.C.

{
  // set up completion item kind value that client may use for icon in list
  auto associated_types = getRegistrationApp().syntax().getAssociatedTypes();
  if (is_param && valid_params.isParamRequired(param_name) &&
      !valid_params.isParamValid(param_name))
    return wasp::lsp::m_comp_kind_event;
  else if (param_name == "active" || param_name == "inactive")
    return wasp::lsp::m_comp_kind_class;
  else if (clean_type == "bool")
    return wasp::lsp::m_comp_kind_interface;
  else if (valid_params.have_parameter<MooseEnum>(param_name) ||
           valid_params.have_parameter<MultiMooseEnum>(param_name) ||
           valid_params.have_parameter<ExecFlagEnum>(param_name) ||
           valid_params.have_parameter<std::vector<MooseEnum>>(param_name))
    return is_param ? wasp::lsp::m_comp_kind_enum : wasp::lsp::m_comp_kind_enum_member;
  else if (param_name == "type")
    return wasp::lsp::m_comp_kind_type_param;
  else if (std::find_if(associated_types.begin(),
                        associated_types.end(),
                        [&](const auto & entry)
                        { return entry.second == clean_type; }) != associated_types.end())
    return wasp::lsp::m_comp_kind_reference;
  else
    return is_param ? wasp::lsp::m_comp_kind_keyword : wasp::lsp::m_comp_kind_value;
}

Referenced by addParametersToList(), and addValuesToList().

getConnection()

std::shared_ptr< wasp::lsp::Connection > MooseServer::getConnection ( )

inline

Get read / write connection - specific to this server implemention.

Returns

- shared pointer to the server's read / write connection

Definition at line 40 of file MooseServer.h.

{ return _connection; }

getDocumentSymbolKind()

int MooseServer::getDocumentSymbolKind ( wasp::HITNodeView  symbol_node )

private

Get document symbol kind value that client may use for outline icon.

Parameters

symbol_node

- node that will be added to symbol tree for kind

Returns

- enumerated kind value that client may use for outline icon

Definition at line 1828 of file MooseServer.C.

{
  // lambdas that check if parameter is a boolean or number for symbol kind
  auto is_boolean = [](wasp::HITNodeView symbol_node)
  {
    bool convert;
    std::istringstream iss(MooseUtils::toLower(symbol_node.last_as_string()));
    return (iss >> std::boolalpha >> convert && !iss.fail());
  };
  auto is_number = [](wasp::HITNodeView symbol_node)
  {
    double convert;
    std::istringstream iss(symbol_node.last_as_string());
    return (iss >> convert && iss.eof());
  };
 
  // set up document symbol kind value that client may use for outline icon
  if (symbol_node.type() == wasp::OBJECT)
    return wasp::lsp::m_symbol_kind_struct;
  else if (symbol_node.type() == wasp::FILE)
    return wasp::lsp::m_symbol_kind_file;
  else if (symbol_node.type() == wasp::ARRAY)
    return wasp::lsp::m_symbol_kind_array;
  else if (symbol_node.type() == wasp::KEYED_VALUE && symbol_node.name() == std::string("type"))
    return wasp::lsp::m_symbol_kind_type_param;
  else if (symbol_node.type() == wasp::KEYED_VALUE && is_boolean(symbol_node))
    return wasp::lsp::m_symbol_kind_boolean;
  else if (symbol_node.type() == wasp::KEYED_VALUE && is_number(symbol_node))
    return wasp::lsp::m_symbol_kind_number;
  else if (symbol_node.type() == wasp::KEYED_VALUE)
    return wasp::lsp::m_symbol_kind_key;
  else if (symbol_node.type() == wasp::VALUE)
    return wasp::lsp::m_symbol_kind_string;
  else
    return wasp::lsp::m_symbol_kind_property;
}

Referenced by gatherDocumentSymbols(), and traverseParseTreeAndFillSymbols().

getEnumsAndDocs()

template<typename MooseEnumType >

void MooseServer::getEnumsAndDocs ( MooseEnumType &  moose_enum_param, std::map< std::string, std::string > &  options_and_descs  )

private

Fill map of all options and descriptions if parameter is moose enum.

Parameters

moose_enum_param	- parameter to get documentation and options
options_and_descs	- map to fill with options and descriptions

Definition at line 1078 of file MooseServer.C.

{
  // get map that contains any documentation strings provided for each item
  const auto & enum_docs = moose_enum_param.getItemDocumentation();
 
  // walk over enums filling map with options and any provided descriptions
  for (const auto & item : moose_enum_param.items())
    options_and_descs[item.name()] = enum_docs.count(item) ? enum_docs.at(item) : "";
}

Referenced by addValuesToList(), and getHoverDisplayText().

getExistingInput()

void MooseServer::getExistingInput ( wasp::HITNodeView  parent_node, std::set< std::string > &  existing_params, std::set< std::string > &  existing_subblocks  )

private

Get names of parameters and subblocks specified in given input node.

Parameters

parent_node	- object node context under which to gather input
existing_params	- set to fill with parameter names from input
existing_subblocks	- set to fill with subblock names in input

Definition at line 557 of file MooseServer.C.

{
  // gather names of all parameters and subblocks provided in input context
  for (auto itr = parent_node.begin(); itr != parent_node.end(); itr.next())
  {
    auto child_node = itr.get();
 
    // add key value or array type as parameter and object type as subblock
    if (child_node.type() == wasp::KEYED_VALUE || child_node.type() == wasp::ARRAY)
      existing_params.insert(child_node.name());
    else if (child_node.type() == wasp::OBJECT)
      existing_subblocks.insert(child_node.name());
  }
}

Referenced by gatherDocumentCompletionItems().

getFileNameTypeValues()

void MooseServer::getFileNameTypeValues ( std::set< std::string > &  filename_vals, wasp::HITNodeView  parent  )

private

Recursively walk input to gather all FileName type parameter values.

Parameters

filename_vals	- set to fill up with FileName parameter values
parent	- nodeview for recursive tree traversal starting point

Definition at line 341 of file MooseServer.C.

{
  // cache set of FileName types for parameters that contain resource files
  static const std::set<std::string> filename_types = {
      "FileName", "FileNameNoExtension", "MeshFileName", "MatrixFileName"};
 
  // walk over children in tree and skip any nodes that are not object type
  for (const auto & child : parent)
  {
    if (child.type() == wasp::OBJECT)
    {
      // get object context path and object type value of node if it exists
      wasp::HITNodeView object_node = child;
      const std::string object_path = object_node.path();
      wasp::HITNodeView type_node = object_node.first_child_by_name("type");
      const std::string object_type =
          type_node.is_null() ? "" : wasp::strip_quotes(hit::extractValue(type_node.data()));
 
      // gather global, action, and object parameters for context of object
      InputParameters valid_params = emptyInputParameters();
      std::set<std::string> obj_act_tasks;
      getAllValidParameters(valid_params, object_path, object_type, obj_act_tasks);
 
      // walk over children and skip any nodes that are not parameter types
      for (const auto & child : object_node)
      {
        if (child.type() == wasp::KEYED_VALUE || child.type() == wasp::ARRAY)
        {
          // get name of node to use for finding in set of valid parameters
          wasp::HITNodeView param_node = child;
          std::string param_name = param_node.name();
 
          // add parameter values to collection if valid with FileName type
          if (valid_params.getParametersList().count(param_name))
          {
            // get parameter type and prepare to check if in FileName types
            std::string dirty_type = valid_params.type(param_name);
            std::string clean_type = MooseUtils::prettyCppType(dirty_type);
            pcrecpp::RE(".+<([A-Za-z0-9_' ':]*)>.*").GlobalReplace("\\1", &clean_type);
 
            // add parameter values to set if type is one of FileName types
            if (filename_types.count(clean_type))
              for (const auto & child : param_node)
                if (child.type() == wasp::VALUE)
                  filename_vals.insert(child.to_string());
          }
        }
      }
 
      // recurse deeper into input and continue search since node is object
      getFileNameTypeValues(filename_vals, object_node);
    }
  }
}

Referenced by addResourcesForDocument(), and getFileNameTypeValues().

getHoverDisplayText()

bool MooseServer::getHoverDisplayText ( std::string &  display_text, int  line, int  character  )

private

Get hover display text - logic specific to this server implemention.

Parameters

display_text	- string reference to add hover text for display
line	- zero-based line to use for finding node and hover text
character	- zero-based column for finding node and hover text

Returns

- true if display text was added or left empty without error

Definition at line 1340 of file MooseServer.C.

{
  Factory & factory = getRegistrationApp().getFactory();
  Syntax & syntax = getRegistrationApp().syntax();
 
  // return and leave display text as empty string when parser root is null
  auto root_ptr = queryRoot();
  if (!root_ptr)
    return true;
  auto & root = *root_ptr;
 
  // find hit node for zero based request line and column number from input
  wasp::HITNodeView view_root = root.getNodeView();
  wasp::HITNodeView request_context =
      wasp::findNodeUnderLineColumn(view_root, line + 1, character + 1);
 
  // return and leave display text as empty string when not on key or value
  if ((request_context.type() != wasp::DECL && request_context.type() != wasp::VALUE) ||
      !request_context.has_parent() ||
      (request_context.parent().type() != wasp::KEYED_VALUE &&
       request_context.parent().type() != wasp::ARRAY))
    return true;
 
  // get name of parameter node and value string that is specified in input
  std::string paramkey = request_context.parent().name();
  std::string paramval = request_context.last_as_string();
 
  // get object context path and object type value for request if it exists
  wasp::HITNodeView object_context = request_context;
  while (object_context.type() != wasp::OBJECT && object_context.has_parent())
    object_context = object_context.parent();
  const std::string object_path = object_context.path();
  wasp::HITNodeView type_node = object_context.first_child_by_name("type");
  const std::string object_type =
      type_node.is_null() ? "" : wasp::strip_quotes(hit::extractValue(type_node.data()));
 
  // gather global, action, and object parameters in request object context
  InputParameters valid_params = emptyInputParameters();
  std::set<std::string> obj_act_tasks;
  getAllValidParameters(valid_params, object_path, object_type, obj_act_tasks);
 
  // use class description as display text when request is Application type
  if (request_context.type() == wasp::VALUE && paramkey == "type" &&
      object_path == "/Application" && AppFactory::instance().isRegistered(paramval))
  {
    InputParameters app_params = AppFactory::instance().getValidParams(paramval);
    display_text = app_params.getClassDescription();
    MooseUtils::escape(display_text);
  }
 
  // use class description as display text when request is valid type value
  else if (request_context.type() == wasp::VALUE && paramkey == "type" &&
           factory.isRegistered(paramval))
  {
    const InputParameters & object_params = factory.getValidParams(paramval);
    if (object_params.hasBase())
    {
      const std::string & moose_base = object_params.getBase();
      for (const auto & obj_act_task : obj_act_tasks)
      {
        if (syntax.verifyMooseObjectTask(moose_base, obj_act_task))
        {
          display_text = object_params.getClassDescription();
          MooseUtils::escape(display_text);
          break;
        }
      }
    }
  }
 
  // use item documentation as display text when request is enum type value
  else if (request_context.type() == wasp::VALUE)
  {
    std::map<std::string, std::string> options_and_descs;
    if (valid_params.have_parameter<MooseEnum>(paramkey))
      getEnumsAndDocs(valid_params.get<MooseEnum>(paramkey), options_and_descs);
    else if (valid_params.have_parameter<MultiMooseEnum>(paramkey))
      getEnumsAndDocs(valid_params.get<MultiMooseEnum>(paramkey), options_and_descs);
    else if (valid_params.have_parameter<ExecFlagEnum>(paramkey))
      getEnumsAndDocs(valid_params.get<ExecFlagEnum>(paramkey), options_and_descs);
    else if (valid_params.have_parameter<std::vector<MooseEnum>>(paramkey))
      getEnumsAndDocs(valid_params.get<std::vector<MooseEnum>>(paramkey)[0], options_and_descs);
    if (options_and_descs.count(paramval))
    {
      display_text = options_and_descs.find(paramval)->second;
      MooseUtils::escape(display_text);
    }
  }
 
  // use parameter documentation as display text when request is valid name
  else if (request_context.type() == wasp::DECL && valid_params.getParametersList().count(paramkey))
  {
    display_text = valid_params.getDocString(paramkey);
    MooseUtils::escape(display_text);
 
    // add units information to hover text if it is specified for parameter
    std::string doc_units = valid_params.getDocUnit(paramkey);
    if (!doc_units.empty())
      display_text += "\n\nUnits: " + doc_units;
 
    // add range information to hover text if it is specified for parameter
    if (valid_params.isRangeChecked(paramkey))
    {
      std::string doc_range = valid_params.rangeCheckedFunction(paramkey);
      if (!doc_range.empty())
        display_text += "\n\nRange: " + doc_range;
    }
  }
 
  return true;
}

getInputLookupDefinitionNodes()

void MooseServer::getInputLookupDefinitionNodes ( SortedLocationNodes &  location_nodes, const std::string &  clean_type, const std::string &  val_string  )

private

Get set of nodes from associated path lookups matching value string.

Parameters

location_nodes	- set to fill with lookup nodes matching value
clean_type	- cpp type string used for key finding input paths
val_string	- specified value used for gathering input lookups

Definition at line 1266 of file MooseServer.C.

{
  Syntax & syntax = getRegistrationApp().syntax();
 
  // build map from parameter types to input lookup paths and save to reuse
  auto & metadata = getSyntaxMetadata();
  if (metadata.type_to_input_paths.empty())
  {
    for (const auto & associated_types_iter : syntax.getAssociatedTypes())
    {
      const std::string & type = associated_types_iter.second;
      const std::string & path = associated_types_iter.first;
      metadata.type_to_input_paths[type].insert(path);
    }
  }
 
  // find set of input lookup paths that are associated with parameter type
  const auto & input_path_iter = metadata.type_to_input_paths.find(clean_type);
 
  // return without any definition locations added when no paths associated
  if (input_path_iter == metadata.type_to_input_paths.end())
    return;
 
  // get root node from input to use in input lookups with associated paths
  wasp::HITNodeView view_root = getRoot().getNodeView();
 
  // walk over all syntax paths that are associated with parameter type
  for (const auto & input_path : input_path_iter->second)
  {
    // use wasp siren to gather all nodes from current lookup path in input
    wasp::SIRENInterpreter<> selector;
    if (!selector.parseString(input_path))
      continue;
    wasp::SIRENResultSet<wasp::HITNodeView> results;
    std::size_t count = selector.evaluate(view_root, results);
 
    // walk over results and add nodes that have name matching value to set
    for (std::size_t i = 0; i < count; i++)
      if (results.adapted(i).type() == wasp::OBJECT && results.adapted(i).name() == val_string &&
          results.adapted(i).child_count_by_name("decl"))
        location_nodes.insert(results.adapted(i).first_child_by_name("decl"));
  }
}

Referenced by gatherDocumentDefinitionLocations().

getNodesByValueAndTypes()

void MooseServer::getNodesByValueAndTypes ( SortedLocationNodes &  match_nodes, wasp::HITNodeView  view_parent, const std::string &  target_value, const std::set< std::string > &  target_types  )

private

Recursively walk input to gather all nodes matching value and types.

Parameters

match_nodes	- set to fill with nodes matching value and types
view_parent	- nodeview used to start recursive tree traversal
target_value	-
target_types	-

Definition at line 1528 of file MooseServer.C.

{
  // walk over children of context to gather nodes matching value and types
  for (const auto & view_child : view_parent)
  {
    // check for parameter type match if node is value matching target data
    if (view_child.type() == wasp::VALUE && view_child.to_string() == target_value)
    {
      // get object context path and object type value of node if it exists
      wasp::HITNodeView object_context = view_child;
      while (object_context.type() != wasp::OBJECT && object_context.has_parent())
        object_context = object_context.parent();
      const std::string object_path = object_context.path();
      wasp::HITNodeView type_node = object_context.first_child_by_name("type");
      const std::string object_type =
          type_node.is_null() ? "" : wasp::strip_quotes(hit::extractValue(type_node.data()));
 
      // gather global, action, and object parameters for context of object
      InputParameters valid_params = emptyInputParameters();
      std::set<std::string> obj_act_tasks;
      getAllValidParameters(valid_params, object_path, object_type, obj_act_tasks);
 
      // get name from parent of current value node which is parameter node
      std::string param_name = view_child.has_parent() ? view_child.parent().name() : "";
 
      // get type of parameter and prepare string to check target set match
      std::string dirty_type = valid_params.type(param_name);
      std::string clean_type = MooseUtils::prettyCppType(dirty_type);
      pcrecpp::RE(".+<([A-Za-z0-9_' ':]*)>.*").GlobalReplace("\\1", &clean_type);
 
      // add input node to collection if its type is also in set of targets
      if (target_types.count(clean_type))
        match_nodes.insert(view_child);
    }
 
    // recurse deeper into input to search for matches if node has children
    if (!view_child.is_leaf())
      getNodesByValueAndTypes(match_nodes, view_child, target_value, target_types);
  }
}

Referenced by gatherDocumentReferencesLocations(), and getNodesByValueAndTypes().

getObjectParameters()

void MooseServer::getObjectParameters ( InputParameters &  valid_params, std::string  object_type, const std::set< std::string > &  obj_act_tasks  )

private

Get all object parameters using requested object path to collection.

Parameters

valid_params	- collection for filling object input parameters
object_type	- type of object where autocomplete was requested
obj_act_tasks	- tasks to verify object type with valid syntax

Definition at line 632 of file MooseServer.C.

{
  Syntax & syntax = getRegistrationApp().syntax();
  Factory & factory = getRegistrationApp().getFactory();
 
  // use type parameter default if it exists and is not provided from input
  if (object_type.empty() && valid_params.have_parameter<std::string>("type") &&
      !valid_params.get<std::string>("type").empty())
  {
    object_type = valid_params.get<std::string>("type");
 
    // make type parameter not required in input since it has default value
    valid_params.makeParamNotRequired("type");
  }
 
  // check if object type has been registered to prevent unregistered error
  if (factory.isRegistered(object_type))
  {
    // use object type to get set of valid parameters registered in factory
    InputParameters object_params = factory.getValidParams(object_type);
 
    // check if object has base associated with any MooseObjectAction tasks
    if (object_params.hasBase())
    {
      const std::string & moose_base = object_params.getBase();
 
      for (const auto & obj_act_task : obj_act_tasks)
      {
        if (syntax.verifyMooseObjectTask(moose_base, obj_act_task))
        {
          // add parameters from object to valid collection if base matches
          valid_params += object_params;
          break;
        }
      }
    }
  }
 
  // make parameters from list of those set by action not required in input
  if (valid_params.have_parameter<std::vector<std::string>>("_object_params_set_by_action"))
  {
    auto names = valid_params.get<std::vector<std::string>>("_object_params_set_by_action");
    for (const auto & name : names)
      valid_params.makeParamNotRequired(name);
 
    // filter parameter from completion list since it is not used for input
    valid_params.remove("_object_params_set_by_action");
  }
}

Referenced by getAllValidParameters().

getRegistrationApp()

MooseApp & MooseServer::getRegistrationApp ( )

private

Returns

- current document check app or fall back to return parent app to get Syntax, Factory, and ActionFactory static registration metadata when parent app could still be beneficial if check app failed to build

Definition at line 2164 of file MooseServer.C.

{
  if (auto * app = queryCheckApp())
    return *app;
  return _moose_app;
}

Referenced by addSubblocksToList(), addValuesToList(), gatherDocumentDefinitionLocations(), gatherDocumentReferencesLocations(), getActionParameters(), getCompletionItemKind(), getHoverDisplayText(), getInputLookupDefinitionNodes(), getObjectParameters(), and getSyntaxMetadata().

getRequiredParamsText()

std::string MooseServer::getRequiredParamsText ( const std::string &  subblock_path, const std::string &  subblock_type, const std::set< std::string > &  existing_params, const std::string &  indent_spaces  )

private

Get required parameter completion text list for given subblock path.

Parameters

subblock_path	- subblock path for finding required parameters
subblock_type	- subblock type for finding required parameters
existing_params	- set of parameters already existing in input
indent_spaces	- indentation to be added before each parameter

Returns

- list of required parameters to use in subblock insert text

Definition at line 1866 of file MooseServer.C.

{
  // gather global, action, and object parameters in request object context
  InputParameters valid_params = emptyInputParameters();
  std::set<std::string> obj_act_tasks;
  getAllValidParameters(valid_params, subblock_path, subblock_type, obj_act_tasks);
 
  // walk over collection of all parameters and build text of ones required
  std::string required_param_text;
  std::size_t param_index = 1;
  for (const auto & valid_params_iter : valid_params)
  {
    // skip parameter if deprecated, private, defaulted, optional, existing
    const std::string & param_name = valid_params_iter.first;
    if (!valid_params.isParamDeprecated(param_name) && !valid_params.isPrivate(param_name) &&
        !valid_params.isParamValid(param_name) && valid_params.isParamRequired(param_name) &&
        !existing_params.count(param_name))
    {
      std::string tab_stop = client_snippet_support ? "$" + std::to_string(param_index++) : "";
      required_param_text += "\n" + indent_spaces + param_name + " = " + tab_stop;
    }
  }
 
  return required_param_text;
}

Referenced by addSubblocksToList(), and addValuesToList().

getRoot()

const hit::Node & MooseServer::getRoot ( ) const

private

Returns

The root node from the check parser for the current document path, with error checking on if it exists

Definition at line 2178 of file MooseServer.C.

{
  if (auto root_ptr = queryRoot())
    return *root_ptr;
  mooseError("MooseServer::getRoot(): Root not available");
}

Referenced by addValuesToList(), and getInputLookupDefinitionNodes().

getSyntaxMetadata()

MooseServer::SyntaxMetadata & MooseServer::getSyntaxMetadata ( )

private

Returns

- syntax metadata for type of current registration application

Definition at line 2172 of file MooseServer.C.

{
  return _app_type_to_syntax_metadata[getRegistrationApp().type()];
}

Referenced by addSubblocksToList(), addValuesToList(), gatherDocumentReferencesLocations(), and getInputLookupDefinitionNodes().

parseDocumentForDiagnostics()

bool MooseServer::parseDocumentForDiagnostics ( wasp::DataArray &  diagnosticsList )

private

Parse document for diagnostics - specific to this server implemention.

Parameters

diagnosticsList

- data array of diagnostics data objects to fill

Returns

- true if completed successfully - does not indicate parse fail

Definition at line 71 of file MooseServer.C.

{
  // Reset old parsers and applications if we have them
  if (const auto it = _check_state.find(document_path); it != _check_state.end())
    _check_state.erase(it);
 
  // strip prefix from document uri if it exists to get parse file path
  std::string parse_file_path = document_path;
  pcrecpp::RE("(.*://)(.*)").Replace("\\2", &parse_file_path);
 
  bool pass = true;
 
  // Adds a single diagnostic
  const auto diagnostic = [this, &diagnosticsList, &pass](const std::string & message,
                                                          const int start_line,
                                                          const int start_column,
                                                          const std::optional<int> end_line = {},
                                                          const std::optional<int> end_column = {})
  {
    diagnosticsList.push_back(wasp::DataObject());
    auto & diagnostic = *diagnosticsList.back().to_object();
    pass &= wasp::lsp::buildDiagnosticObject(diagnostic,
                                             errors,
                                             start_line,
                                             start_column,
                                             end_line ? *end_line : start_line,
                                             end_column ? *end_column : start_column,
                                             1,
                                             "moose_srv",
                                             "check_inp",
                                             message);
  };
 
  // Adds a diagnostic on line zero
  const auto zero_line_diagnostic = [&diagnostic](const std::string & message)
  { diagnostic(message, 0, 0); };
 
  // Adds a diagnostic from a hit node, if the context of the hit node is valid
  const auto hit_node_diagnostic = [&zero_line_diagnostic, &diagnostic, &parse_file_path](
                                       const hit::Node * const node, const std::string & message)
  {
    // No node, root node, wrong file, or no line information: line zero diagnostic
    if (!node || node->isRoot() || node->filename() != parse_file_path || !node->line() ||
        !node->column())
      zero_line_diagnostic(message);
    // Have file and line context, diagnostic there
    else
      diagnostic(message, node->line() - 1, node->column() - 1);
  };
 
  // Adds a diagnostic from a hit::ErrorMessage if the context is valid
  const auto hit_error_message_diagnostic =
      [&diagnostic, &zero_line_diagnostic, &parse_file_path](const hit::ErrorMessage & err)
  {
    // Has a filename
    if (err.filename)
    {
      // For the open file
      if (*err.filename == parse_file_path)
      {
        // Has line information that is valid
        if (err.lineinfo && err.lineinfo->start_line && err.lineinfo->start_column &&
            err.lineinfo->end_line && err.lineinfo->end_column)
        {
          diagnostic(err.message,
                     err.lineinfo->start_line - 1,
                     err.lineinfo->start_column - 1,
                     err.lineinfo->end_line - 1,
                     err.lineinfo->end_column - 1);
          return;
        }
      }
      // Has a file but not for this file, no diagnostic
      else
        return;
    }
 
    // Don't have a filename, or have a filename that is this file without line info
    zero_line_diagnostic(err.prefixed_message);
  };
 
  // Runs a try catch loop with the given action, collecting diagnostics
  // from the known exceptions; returns a bool that is true if we executed
  // without throwing anything
  const auto try_catch = [&hit_error_message_diagnostic,
                          &hit_node_diagnostic,
                          &zero_line_diagnostic](const auto & action) -> bool
  {
    Moose::ScopedThrowOnError scoped_throw_on_error;
 
    try
    {
      action();
    }
    // Will be thrown from the Parser while building the tree or
    // by the builder while building the input parameters
    catch (Parser::Error & err)
    {
      for (const auto & error_message : err.error_messages)
        hit_error_message_diagnostic(error_message);
    }
    // Will be thrown by mooseError() when _throw_on_error is set
    // to true, hopefully with hit node context
    catch (MooseRuntimeError & err)
    {
      hit_node_diagnostic(err.getNode(), err.what());
    }
    // General catch all for everything else without context
    catch (std::exception & err)
    {
      zero_line_diagnostic(err.what());
    }
 
    // continue to build app if parsing fails and run app if building fails
    // so that problem is there for plotting and warehouse based completion
    return true;
  };
 
  // Setup command line (needed by the Parser)
  auto command_line = std::make_unique<CommandLine>(_moose_app.commandLine()->getArguments());
  if (command_line->hasArgument("--language-server"))
    command_line->removeArgument("--language-server");
  command_line->addArgument("--check-input");
  command_line->addArgument("--error-unused");
  command_line->addArgument("--error");
  command_line->addArgument("--color=off");
  command_line->addArgument("--disable-perf-graph-live");
  command_line->parse();
 
  // Setup the parser that will be used in the app
  auto parser = std::make_shared<Parser>(parse_file_path, document_text);
  mooseAssert(parser->getInputFileNames()[0] == parse_file_path, "Should be consistent");
  parser->setAppType(_moose_app.type());
  parser->setCommandLineParams(command_line->buildHitParams());
  parser->setThrowOnError(true);
 
  // Try to parse the document
  const bool parse_success = try_catch([&parser]() { parser->parse(); });
  // If the Parser has a valid root, store it because we can use it
  // in the future (hover text etc with a partially complete document)
  CheckState * state = nullptr;
  if (auto parser_root_ptr = parser->queryRoot();
      parser_root_ptr && !parser_root_ptr->getNodeView().is_null())
  {
    auto it_inserted_pair = _check_state.emplace(document_path, parser);
    mooseAssert(it_inserted_pair.second, "Should not already exist");
    state = &it_inserted_pair.first->second;
  }
  // We have no root or an empty document, nothing else to do
  else
    return true;
 
  // Failed to parse, don't bother building the app. But... we might
  // have a root node at least!
  if (!parse_success)
    return pass;
 
  // Try to instantiate the application
  std::unique_ptr<MooseApp> app = nullptr;
  const auto do_build_app = [this, &parse_file_path, &diagnostic, &parser, &command_line, &app]()
  {
    // get app type from parser which is Application block type if provided
    const std::string & app_type = parser->getAppType();
 
    // error if Application type specified in input has not been registered
    if (!AppFactory::instance().isRegistered(app_type))
    {
      // get line and column range of Application/type/value for diagnostic
      int error_line_beg = 0, error_char_beg = 0, error_line_end = 0, error_char_end = 0;
      if (auto app_type_field = parser->getRoot().find("Application/type");
          app_type_field && app_type_field->filename() == parse_file_path)
      {
        auto app_type_value = app_type_field->getNodeView().first_child_by_name("value");
        if (!app_type_value.is_null())
        {
          error_line_beg = app_type_value.line() - 1;
          error_char_beg = app_type_value.column() - 1;
          error_line_end = app_type_value.last_line() - 1;
          error_char_end = app_type_value.last_column();
        }
      }
 
      // build error message string with available app types for diagnostic
      std::vector<std::string> app_types;
      for (const auto & apps_iter : AppFactory::instance().registeredObjects())
        app_types.push_back(apps_iter.first);
      const auto message = "'" + app_type + "' is not a registered application type. Registered" +
                           " application types are [" + MooseUtils::join(app_types, ", ") + "].";
 
      // add diagnostic to get reported for Application/type not registered
      diagnostic(message, error_line_beg, error_char_beg, error_line_end, error_char_end);
      return;
    }
 
    // set up options from app type parameters with parser and command line
    InputParameters app_params = AppFactory::instance().getValidParams(app_type);
    app_params.set<std::shared_ptr<Parser>>("_parser") = parser;
    app_params.set<std::shared_ptr<CommandLine>>("_command_line") = std::move(command_line);
 
    // create application to use for diagnostic checks and input assistance
    app = AppFactory::instance().create(
        app_type, AppFactory::main_app_name, app_params, _moose_app.getCommunicator()->get());
  };
  if (!try_catch(do_build_app))
  {
    if (app)
      app.reset();
    return pass;
  }
 
  // do not attempt to run application if it is null after build from error
  if (app)
  {
    // store application when it is valid and then run it to invoke builder
    state->app = std::move(app);
    const auto do_run_app = [this]() { getCheckApp().run(); };
    if (!try_catch(do_run_app))
      state->app.reset();
  }
 
  // add all resource files of document that will be registered with client
  addResourcesForDocument();
 
  return pass;
}

queryCheckApp() [1/2]

MooseApp * MooseServer::queryCheckApp ( )

private

Definition at line 2145 of file MooseServer.C.

{
  return const_cast<MooseApp *>(std::as_const(*this).queryCheckApp());
}

queryCheckApp() [2/2]

const MooseApp * MooseServer::queryCheckApp ( ) const

private

Returns

The check app for the current document path, if any

Definition at line 2137 of file MooseServer.C.

{
  if (auto state = queryCheckState())
    return state->app.get();
  return nullptr;
}

Referenced by addObjectsFromWarehouses(), gatherPlottingResponses(), getCheckApp(), getRegistrationApp(), and queryRoot().

queryCheckParser() [1/2]

Parser * MooseServer::queryCheckParser ( )

private

Definition at line 2131 of file MooseServer.C.

{
  return const_cast<Parser *>(std::as_const(*this).queryCheckParser());
}

queryCheckParser() [2/2]

const Parser * MooseServer::queryCheckParser ( ) const

private

Returns

The check parser for the current document path, if any

Definition at line 2124 of file MooseServer.C.

{
  const auto state = queryCheckState();
  return state ? state->parser.get() : nullptr;
}

Referenced by getCheckApp(), and queryRoot().

queryCheckState() [1/2]

MooseServer::CheckState * MooseServer::queryCheckState ( )

private

Definition at line 2118 of file MooseServer.C.

{
  return const_cast<MooseServer::CheckState *>(std::as_const(*this).queryCheckState());
}

queryCheckState() [2/2]

const MooseServer::CheckState * MooseServer::queryCheckState ( ) const

private

Returns

The check state for the current document path, if any

Definition at line 2111 of file MooseServer.C.

{
  const auto it = _check_state.find(document_path);
  return it == _check_state.end() ? nullptr : &it->second;
}

Referenced by queryCheckApp(), and queryCheckParser().

queryRoot()

const hit::Node * MooseServer::queryRoot ( ) const

private

Returns

The root node from the check parser for the current document path, if any

Definition at line 2095 of file MooseServer.C.

{
  if (const auto parser_ptr = queryCheckParser())
  {
#ifndef NDEBUG
    if (const auto app_ptr = queryCheckApp())
      mooseAssert(&app_ptr->parser() == parser_ptr, "App should have this parser");
#endif
    if (const auto root_ptr = parser_ptr->queryRoot())
      if (!root_ptr->getNodeView().is_null())
        return root_ptr;
  }
  return nullptr;
}

Referenced by addResourcesForDocument(), gatherDocumentCompletionItems(), gatherDocumentDefinitionLocations(), gatherDocumentReferencesLocations(), gatherDocumentSymbols(), gatherPlottingResponses(), getHoverDisplayText(), and getRoot().

rootIsValid()

bool MooseServer::rootIsValid ( ) const

private

Returns

Whether or not the root is valid

Will be true if the app is valid, the root is not nullptr, and the root node view is not null

setDistPlotNumPoints()

void MooseServer::setDistPlotNumPoints ( std::size_t  num_points )

inline

Override number of discrete points in continuous distribution plots.

Used by plotting unit test to lower sampling resolution for testing.

Parameters

num_points

- number of discrete points for distribution plots

Definition at line 53 of file MooseServer.h.

{ _dist_plot_num_points = num_points; }

traverseParseTreeAndFillSymbols()

bool MooseServer::traverseParseTreeAndFillSymbols ( wasp::HITNodeView  view_parent, wasp::DataObject &  data_parent  )

private

Recursively fill document symbols from the given node.

Parameters

view_parent	- nodeview used in recursive tree traversal
data_parent	- data object with array of symbol children

Returns

- true if no problems with this level of the resursion

Definition at line 1745 of file MooseServer.C.

{
  // return without adding any children if parent node is file include type
  if (wasp::is_nested_file(view_parent))
    return true;
 
  bool pass = true;
 
  // walk over all children of this node context and build document symbols
  for (const auto i : make_range(view_parent.child_count()))
  {
    // walk must be index based to catch file include and skip its children
    wasp::HITNodeView view_child = view_parent.child_at(i);
 
    // set up name, zero based line and column range, kind, and detail info
    std::string name = view_child.name();
    int line = view_child.line() - 1;
    int column = view_child.column() - 1;
    int last_line = view_child.last_line() - 1;
    int last_column = view_child.last_column();
    int symbol_kind = getDocumentSymbolKind(view_child);
    std::string detail =
        !view_child.first_child_by_name("type").is_null()
            ? wasp::strip_quotes(hit::extractValue(view_child.first_child_by_name("type").data()))
            : "";
 
    // build document symbol object from node child info and push to array
    wasp::DataObject & data_child = wasp::lsp::addDocumentSymbolChild(data_parent);
    pass &= wasp::lsp::buildDocumentSymbolObject(data_child,
                                                 errors,
                                                 (name.empty() ? "void" : name),
                                                 detail,
                                                 symbol_kind,
                                                 false,
                                                 line,
                                                 column,
                                                 last_line,
                                                 last_column,
                                                 line,
                                                 column,
                                                 last_line,
                                                 last_column);
 
    // call method to recursively fill document symbols for each node child
    pass &= traverseParseTreeAndFillSymbols(view_child, data_child);
  }
 
  return pass;
}

Referenced by gatherDocumentSymbols(), and traverseParseTreeAndFillSymbols().

Member Data Documentation

_app_type_to_syntax_metadata

std::map<std::string, SyntaxMetadata> MooseServer::_app_type_to_syntax_metadata

private

_app_type_to_syntax_metadata - syntax metadata per app type map

Definition at line 519 of file MooseServer.h.

Referenced by getSyntaxMetadata().

_check_state

std::map<std::string, CheckState> MooseServer::_check_state

private

_check_state - map from document paths to state (parser, app, text)

Definition at line 509 of file MooseServer.h.

Referenced by parseDocumentForDiagnostics(), and queryCheckState().

_connection

std::shared_ptr<wasp::lsp::IOStreamConnection> MooseServer::_connection

private

_connection - shared pointer to this server's read / write iostream

Definition at line 514 of file MooseServer.h.

Referenced by connectionRead(), connectionWrite(), and getConnection().

_dist_plot_num_points

std::size_t MooseServer::_dist_plot_num_points

private

_dist_plot_num_points - distribution plot sampling resolution

Definition at line 529 of file MooseServer.h.

Referenced by buildDistPlotResponses(), and setDistPlotNumPoints().

_dist_plot_quantile_bound

double MooseServer::_dist_plot_quantile_bound

private

_dist_plot_quantile_bound - epsilon to bound plot range tails

Definition at line 534 of file MooseServer.h.

Referenced by buildDistPlotResponses().

_formatting_tab_size

std::size_t MooseServer::_formatting_tab_size

private

_formatting_tab_size - number of indent spaces for formatting

Definition at line 524 of file MooseServer.h.

Referenced by formatDocument(), and gatherDocumentFormattingTextEdits().

_moose_app

MooseApp& MooseServer::_moose_app

private

_moose_app - reference to parent application that owns this server

Definition at line 504 of file MooseServer.h.

Referenced by getRegistrationApp(), and parseDocumentForDiagnostics().

---

The documentation for this class was generated from the following files:

• include/base/MooseServer.h
• src/base/MooseServer.C