stan-language-server-bin 0.4.5 → 0.4.7

package/bin/cli.js

@@ -9871,24 +9871,60 @@ function getWellformedEdit(textEdit) {
 var import_node = __toESM(require_main4(), 1);
 
 // src/handlers/completion.ts
+var import_vscode_languageserver7 = __toESM(require_main4(), 1);
+var import_trie_search = __toESM(require_TrieSearch(), 1);
+
+// src/handlers/completion/constraints.ts
 var import_vscode_languageserver = __toESM(require_main4(), 1);
+function constraintToCompletionItem(constraint) {
+  return {
+    label: constraint,
+    kind: import_vscode_languageserver.CompletionItemKind.Property
+  };
+}
+var CONSTRAINTS = ["lower", "upper", "offset", "multiplier"].map(constraintToCompletionItem);
 
-// src/language/completion/util.ts
-var import_trie_search = __toESM(require_TrieSearch(), 1);
-var getSearchableItems = (xs, options = {}) => {
-  const searchableItem = new import_trie_search.default("name", options);
-  searchableItem.addAll(xs);
-  return searchableItem;
-};
-var getTextUpToCursor = (text, position) => {
-  const lines = text.split(`
-`);
-  const currentLine = lines[position.line] || "";
-  return currentLine.substring(0, position.character);
-};
+// src/handlers/completion/datatypes.ts
+var import_vscode_languageserver2 = __toESM(require_main4(), 1);
+function datatypeToCompletionItem(datatype) {
+  return {
+    label: datatype,
+    kind: import_vscode_languageserver2.CompletionItemKind.Class
+  };
+}
+var DATATYPES = [
+  "void",
+  "int",
+  "real",
+  "complex",
+  "vector",
+  "row_vector",
+  "matrix",
+  "complex_vector",
+  "complex_row_vector",
+  "complex_matrix",
+  "ordered",
+  "positive_ordered",
+  "simplex",
+  "unit_vector",
+  "sum_to_zero_vector",
+  "cholesky_factor_corr",
+  "cholesky_factor_cov",
+  "corr_matrix",
+  "cov_matrix",
+  "stochastic_column_matrix",
+  "stochastic_row_matrix"
+].map(datatypeToCompletionItem);
 
-// src/language/completion/providers/keywords.ts
-var ALL_KEYWORDS = [
+// src/handlers/completion/keywords.ts
+var import_vscode_languageserver3 = __toESM(require_main4(), 1);
+function keywordToCompletionItem(keyword) {
+  return {
+    label: keyword,
+    kind: import_vscode_languageserver3.CompletionItemKind.Keyword
+  };
+}
+var KEYWORDS = [
   "for",
   "in",
   "while",
@@ -9930,94 +9966,137 @@ var ALL_KEYWORDS = [
   "tuple",
   "truncate",
   "jacobian"
-];
-var getKeywords = () => {
-  return ALL_KEYWORDS.map((keyword) => ({
-    name: keyword
-  }));
-};
-var provideKeywordCompletions = (text, position) => {
-  const textUpToCursor = getTextUpToCursor(text, position);
-  const keywords = getKeywords();
-  const searchableKeywords = getSearchableItems(keywords, {
-    splitOnRegEx: /[\s_]/g,
-    min: 0
-  });
-  const match = textUpToCursor.match(/(?:^|\s)([\w_]+)$/);
-  if (match) {
-    const keywordName = match[1] || "";
-    const completionProposals = searchableKeywords.search(keywordName);
-    return completionProposals;
-  }
-  return [];
-};
+].map(keywordToCompletionItem);
 
-// src/language/completion/providers/distributions.ts
-var provideDistributionCompletions = (text, position, distributions) => {
-  const textUpToCursor = getTextUpToCursor(text, position);
-  const distributionItems = distributions.filter((name) => name !== "").map((name) => ({ name }));
-  const searchableDistributions = getSearchableItems(distributionItems, {
-    splitOnRegEx: /[\s_]/g,
-    min: 0
-  });
-  const match = textUpToCursor.match(/.*~\s*([\w_]*)$/);
-  if (match) {
-    const distName = match[1] || "";
-    let completionProposals;
-    if (distName === "") {
-      completionProposals = distributionItems;
-    } else {
-      completionProposals = searchableDistributions.search(distName);
-    }
-    return completionProposals;
+// src/handlers/completion/snippets.ts
+var import_vscode_languageserver4 = __toESM(require_main4(), 1);
+function snippetToCompletionItem(snippet) {
+  return {
+    label: snippet.name,
+    kind: import_vscode_languageserver4.CompletionItemKind.Snippet,
+    insertText: snippet.body.join(`
+`),
+    insertTextFormat: import_vscode_languageserver4.InsertTextFormat.Snippet,
+    insertTextMode: import_vscode_languageserver4.InsertTextMode.adjustIndentation,
+    detail: snippet.description
+  };
+}
+var SNIPPETS = [
+  {
+    name: "else",
+    body: ["else {", "   ${0:/* code */}", "}"],
+    description: "Code snippet for 'else' conditional"
+  },
+  {
+    name: "elseif",
+    body: ["else if (${1:/* condition */}) {", "   ${0:/* code */}", "}"],
+    description: "Code snippet for 'else if' conditional"
+  },
+  {
+    name: "for",
+    body: [
+      "for (${1:identifier} in ${2:collection}) {",
+      "   ${0:/* code */}",
+      "}"
+    ],
+    description: "Code snippet for 'for' loop"
+  },
+  {
+    name: "if",
+    body: ["if (${1:/* condition */}) {", "   ${0:/* code */}", "}"],
+    description: "Code snippet for 'if' conditional"
+  },
+  {
+    name: "ifelse",
+    body: [
+      "if (${1:/* condition */}) {",
+      "   ${2:/* code */}",
+      "} else {",
+      "   ${0:/* code */}",
+      "}"
+    ],
+    description: "Code snippet for 'if-else' conditional block"
+  },
+  {
+    name: "while",
+    body: ["while (${1:/* condition */}) {", "   ${0:/* code */}", "}"],
+    description: "Code snippet for 'while' loop"
+  },
+  {
+    name: "profile",
+    body: ['profile("${1:name}") {', "   ${0:/* code to be profiled */}", "}"],
+    description: "Code snippet for 'profile' block"
+  },
+  {
+    name: "data",
+    body: ["data {", "   ${0:/* ... declarations ... */}", "}"],
+    description: "Code snippet for 'data' block"
+  },
+  {
+    name: "transformed data",
+    body: [
+      "transformed data {",
+      "   ${0:/* ... declarations ... statements ... */}",
+      "}"
+    ],
+    description: "Code snippet for 'transformed data' block"
+  },
+  {
+    name: "parameters",
+    body: ["parameters {", "   ${0:/* ... declarations ... */}", "}"],
+    description: "Code snippet for 'parameters' block"
+  },
+  {
+    name: "transformed parameters",
+    body: [
+      "transformed parameters {",
+      "   ${0:/* ... declarations ... statements ... */}",
+      "}"
+    ],
+    description: "Code snippet for 'transformed parameters' block"
+  },
+  {
+    name: "model",
+    body: ["model {", "   ${0:/* ... declarations ... statements ... */}", "}"],
+    description: "Code snippet for 'model' block"
+  },
+  {
+    name: "generated quantities",
+    body: [
+      "generated quantities {",
+      "   ${0:/* ... declarations ... statements ... */}",
+      "}"
+    ],
+    description: "Code snippet for 'generated quantities' block"
+  },
+  {
+    name: "functions",
+    body: [
+      "functions {",
+      "   ${0:/* ... function declarations and definitions ... */}",
+      "}"
+    ],
+    description: "Code snippet for 'functions' block"
+  },
+  {
+    name: "include",
+    body: ['#include "${1:filename}"'],
+    description: "Code snippet for 'include' preprocessor"
+  },
+  {
+    name: "target",
+    body: ["target += ${1};"],
+    description: "Code snippet for 'target +=' statement"
+  },
+  {
+    name: "jacobian",
+    body: ["jacobian += ${1};"],
+    description: "Code snippet for 'jacobian +=' statement"
   }
-  return [];
-};
+].map(snippetToCompletionItem);
 
-// src/language/completion/providers/datatypes.ts
-var DATATYPES = [
-  "void",
-  "int",
-  "real",
-  "complex",
-  "vector",
-  "row_vector",
-  "matrix",
-  "complex_vector",
-  "complex_row_vector",
-  "complex_matrix",
-  "ordered",
-  "positive_ordered",
-  "simplex",
-  "unit_vector",
-  "sum_to_zero_vector",
-  "cholesky_factor_corr",
-  "cholesky_factor_cov",
-  "corr_matrix",
-  "cov_matrix",
-  "stochastic_column_matrix",
-  "stochastic_row_matrix"
-];
-var getDatatypes = () => {
-  return DATATYPES.map((datatype) => ({
-    name: datatype
-  }));
-};
-var provideDatatypeCompletions = (text, position) => {
-  const textUpToCursor = getTextUpToCursor(text, position);
-  const datatypes = getDatatypes();
-  const searchableDatatypes = getSearchableItems(datatypes, {
-    splitOnRegEx: /[\s_]/g,
-    min: 0
-  });
-  const match = textUpToCursor.match(/(?:^|\s)([\w_]+)$/);
-  if (match) {
-    const typeName = match[1] || "";
-    const completionProposals = searchableDatatypes.search(typeName);
-    return completionProposals;
-  }
-  return [];
-};
+// src/handlers/completion/distributions.ts
+var import_vscode_languageserver5 = __toESM(require_main4(), 1);
 
 // node_modules/stanc3/dist/index.js
 var stanc_default = `// Generated by js_of_ocaml
@@ -29967,6 +30046,23 @@ if (typeof module_dist !== "undefined") {
 }
 var stanc_version = stanc("", "", ["version"]).result;
 
+// src/handlers/completion/distributions.ts
+function distributionToCompletionItem(distribution) {
+  return {
+    label: distribution,
+    kind: import_vscode_languageserver5.CompletionItemKind.Function
+  };
+}
+var getDistributions = () => {
+  const distributions = dump_stan_math_distributions().split(`
+`).map((line) => line.split(":")[0]?.trim() ?? "").filter((name) => name !== "");
+  return distributions.map(distributionToCompletionItem);
+};
+var DISTRIBUTIONS = getDistributions();
+
+// src/handlers/completion/functions.ts
+var import_vscode_languageserver6 = __toESM(require_main4(), 1);
+
 // src/language/hover/util.ts
 var isWordChar = (char) => {
   const code = char.charCodeAt(0);
@@ -30161,122 +30257,84 @@ async function handleHover(document, params) {
 }
 var hover_default = handleHover;
 
-// src/language/completion/providers/functions.ts
-var provideFunctionCompletions = (text, position, functionSignatures) => {
-  const textUpToCursor = getTextUpToCursor(text, position);
-  const functionNames = functionSignatures.map((line) => line.split("(", 1)[0]?.trim() ?? "").filter((name) => name !== "");
-  const allFunctionNames = [...new Set([...functionNames, ...manual_functions])];
-  const functionItems = allFunctionNames.map((name) => ({ name }));
-  const searchableFunctions = getSearchableItems(functionItems, {
-    splitOnRegEx: /[\s_]/g,
-    min: 0
-  });
+// src/handlers/completion/functions.ts
+function functionToCompletionItem(func) {
+  return {
+    label: func,
+    kind: import_vscode_languageserver6.CompletionItemKind.Function
+  };
+}
+var getFunctions = () => {
+  const functions = dump_stan_math_signatures().split(`
+`);
+  const functionNames = functions.map((line) => line.split("(", 1)[0]?.trim() ?? "").filter((name) => name !== "");
+  const uniqueFunctions = [...new Set([...functionNames, ...manual_functions])];
+  return uniqueFunctions.map(functionToCompletionItem);
+};
+var FUNCTIONS = getFunctions();
+
+// src/handlers/completion.ts
+var COMPLETION_TRIE = new import_trie_search.default("label", {
+  splitOnRegEx: /[\s_]/g,
+  min: 0
+});
+COMPLETION_TRIE.addAll([
+  ...CONSTRAINTS,
+  ...DATATYPES,
+  ...KEYWORDS,
+  ...FUNCTIONS,
+  ...SNIPPETS
+]);
+var searchWords = (textUpToCursor, supportsSnippets) => {
   const match = textUpToCursor.match(/(?:^|\s)([\w_]+)$/);
   if (match) {
-    const functionName = match[1] || "";
-    const completionProposals = searchableFunctions.search(functionName);
+    const word = match[1] || "";
+    const completionProposals = COMPLETION_TRIE.search(word);
+    if (!supportsSnippets) {
+      return completionProposals.filter((item) => item.kind !== import_vscode_languageserver7.CompletionItemKind.Snippet);
+    }
     return completionProposals;
   }
   return [];
 };
-
-// src/language/completion/providers/constraints.ts
-var CONSTRAINTS = [
-  "lower",
-  "upper",
-  "offset",
-  "multiplier",
-  "ordered",
-  "positive_ordered",
-  "simplex",
-  "unit_vector",
-  "sum_to_zero_vector",
-  "cholesky_factor_corr",
-  "cholesky_factor_cov",
-  "corr_matrix",
-  "cov_matrix",
-  "stochastic_column_matrix",
-  "stochastic_row_matrix"
-];
-var getConstraints = () => {
-  return CONSTRAINTS.map((constraint) => ({
-    name: constraint
-  }));
-};
-var provideConstraintCompletions = (text, position) => {
-  const textUpToCursor = getTextUpToCursor(text, position);
-  const constraints = getConstraints();
-  const searchableConstraints = getSearchableItems(constraints, {
-    splitOnRegEx: /[\s_]/g,
-    min: 0
-  });
-  const match = textUpToCursor.match(/(?:^|\s)([\w_]+)$/);
+var DISTRIBUTION_TRIE = new import_trie_search.default("label", {
+  splitOnRegEx: /[\s_]/g,
+  min: 0
+});
+DISTRIBUTION_TRIE.addAll(DISTRIBUTIONS);
+var searchDistributions = (textUpToCursor) => {
+  const match = textUpToCursor.match(/.*~\s*([\w_]*)$/);
   if (match) {
-    const constraintName = match[1] || "";
-    const completionProposals = searchableConstraints.search(constraintName);
+    const distName = match[1] || "";
+    let completionProposals;
+    if (distName === "") {
+      completionProposals = DISTRIBUTIONS;
+    } else {
+      completionProposals = DISTRIBUTION_TRIE.search(distName);
+    }
     return completionProposals;
   }
   return [];
 };
-
-// src/handlers/completion.ts
-function keywordToCompletionItem(keyword) {
-  return {
-    label: keyword.name,
-    kind: import_vscode_languageserver.CompletionItemKind.Keyword
-  };
-}
-function distributionToCompletionItem(distribution) {
-  return {
-    label: distribution.name,
-    kind: import_vscode_languageserver.CompletionItemKind.Function
-  };
-}
-function datatypeToCompletionItem(datatype) {
-  return {
-    label: datatype.name,
-    kind: import_vscode_languageserver.CompletionItemKind.Class
-  };
-}
-function functionToCompletionItem(func) {
-  return {
-    label: func.name,
-    kind: import_vscode_languageserver.CompletionItemKind.Function
-  };
-}
-function constraintToCompletionItem(constraint) {
-  return {
-    label: constraint.name,
-    kind: import_vscode_languageserver.CompletionItemKind.Property
-  };
-}
-var DISTRIBUTION_DATA = dump_stan_math_distributions().split(`
-`).map((line) => line.split(":")[0]?.trim() ?? "").filter((name) => name !== "");
-var FUNCTION_DATA = dump_stan_math_signatures().split(`
+var getTextUpToCursor = (text, position) => {
+  const lines = text.split(`
 `);
-function handleCompletion(params, documents) {
+  const currentLine = lines[position.line] || "";
+  return currentLine.substring(0, position.character);
+};
+function handleCompletion(params, documents, supportsSnippets) {
   const document = documents.get(params.textDocument.uri);
-  if (!document) {
+  if (!document || !document.languageId.startsWith("stan")) {
     return [];
   }
-  const text = document.getText();
-  const position = params.position;
-  const keywords = provideKeywordCompletions(text, position);
-  const distributions = provideDistributionCompletions(text, position, DISTRIBUTION_DATA);
-  const datatypes = provideDatatypeCompletions(text, position);
-  const functions = provideFunctionCompletions(text, position, FUNCTION_DATA);
-  const constraints = provideConstraintCompletions(text, position);
-  const allItems = [
-    ...keywords.map(keywordToCompletionItem),
-    ...distributions.map(distributionToCompletionItem),
-    ...datatypes.map(datatypeToCompletionItem),
-    ...functions.map(functionToCompletionItem),
-    ...constraints.map(constraintToCompletionItem)
+  const textUpToCursor = getTextUpToCursor(document.getText(), params.position);
+  return [
+    ...searchDistributions(textUpToCursor),
+    ...searchWords(textUpToCursor, supportsSnippets)
   ];
-  return allItems;
 }
 // src/handlers/diagnostics.ts
-var import_vscode_languageserver2 = __toESM(require_main4(), 1);
+var import_vscode_languageserver8 = __toESM(require_main4(), 1);
 
 // src/constants/index.ts
 var SERVER_ID = "stan-language-server";
@@ -30814,7 +30872,7 @@ var readIncludedFileFromFileSystem = async (filename, dirs, fileSystemReader) =>
       const localPath = join(currentDir, filename);
       const content = await fileSystemReader(localPath);
       return TextDocument.create(URI.file(localPath).toString(), "stan", 0, content);
-    } catch (error) {}
+    } catch (_error) {}
   }
   return Promise.resolve({ msg: `File not found: ${filename}` });
 };
@@ -30822,44 +30880,44 @@ var readIncludedFileFromFileSystem = async (filename, dirs, fileSystemReader) =>
 // src/handlers/compilation/compilation.ts
 var defaultSettings = {
   maxLineLength: 78,
-  includePaths: []
+  includePaths: [],
+  warnPedantic: false
 };
-async function handleCompilation(document, documentManager, workspaceFolders, settings, logger, reader) {
+async function handleCompilation(document, documentManager, workspaceFolders, settings, purpose, logger, reader) {
   const filename = URI.parse(document.uri).fsPath;
   const code = document.getText();
   const includes = await handleIncludes(document, documentManager, workspaceFolders, settings.includePaths, logger, reader);
-  const stanc_args = [
-    "auto-format",
-    `filename-in-msg=${filename}`,
-    `max-line-length=${settings.maxLineLength}`,
-    "canonicalze=deprecations",
-    "allow-undefined"
-  ];
+  const stanc_args = [`filename-in-msg=${filename}`, "allow-undefined"];
   if (filename.endsWith(".stanfunctions")) {
     stanc_args.push("functions-only");
   }
+  if (purpose === "formatting") {
+    stanc_args.push("auto-format", `max-line-length=${settings.maxLineLength}`, "canonicalze=deprecations");
+  } else if (settings.warnPedantic) {
+    stanc_args.push("warn-pedantic");
+  }
   return Promise.resolve(stanc(filename, code, stanc_args, includes));
 }
 
 // src/handlers/diagnostics.ts
 async function handleDiagnostics(params, documents, workspaceFolders, settings, logger, reader) {
   const document = documents.get(params.textDocument.uri);
-  if (!document) {
+  if (!document || !document.languageId.startsWith("stan")) {
     return [];
   }
-  const compilerResult = await handleCompilation(document, documents, workspaceFolders, settings, logger, reader);
+  const compilerResult = await handleCompilation(document, documents, workspaceFolders, settings, "linting", logger, reader);
   const diagnostics = provideDiagnostics(compilerResult).map((diagnostic) => {
     if (diagnostic.severity === "error") {
       return {
         range: diagnostic.range,
-        severity: import_vscode_languageserver2.DiagnosticSeverity.Error,
+        severity: import_vscode_languageserver8.DiagnosticSeverity.Error,
         message: diagnostic.message,
         source: SERVER_ID
       };
     } else if (diagnostic.severity === "warning") {
       return {
         range: diagnostic.range,
-        severity: import_vscode_languageserver2.DiagnosticSeverity.Warning,
+        severity: import_vscode_languageserver8.DiagnosticSeverity.Warning,
         message: diagnostic.message,
         source: SERVER_ID
       };
@@ -30870,10 +30928,10 @@ async function handleDiagnostics(params, documents, workspaceFolders, settings,
 // src/handlers/formatting.ts
 async function handleFormatting(params, documents, workspaceFolders, settings, logger, reader) {
   const document = documents.get(params.textDocument.uri);
-  if (!document) {
+  if (!document || !document.languageId.startsWith("stan")) {
     return [];
   }
-  const result = await handleCompilation(document, documents, workspaceFolders, settings, logger, reader);
+  const result = await handleCompilation(document, documents, workspaceFolders, settings, "formatting", logger, reader);
   if (result.errors && result.errors.length > 0) {
     return { errors: result.errors };
   } else if (result.result) {
@@ -30898,12 +30956,14 @@ var startLanguageServer = (connection, reader) => {
   let hasConfigurationCapability = false;
   let hasWorkspaceFolderCapability = false;
   let hasDynamicConfigurationRequestCapability = false;
+  let hasSnippetSupport = false;
   connection.onInitialize((params) => {
     connection.console.info("Initializing Stan language server...");
-    let capabilities = params.capabilities;
+    const capabilities = params.capabilities;
     hasConfigurationCapability = Boolean(capabilities.workspace?.configuration);
     hasDynamicConfigurationRequestCapability = Boolean(capabilities.workspace?.configuration && capabilities.workspace?.didChangeConfiguration?.dynamicRegistration);
     hasWorkspaceFolderCapability = Boolean(capabilities.workspace?.workspaceFolders);
+    hasSnippetSupport = Boolean(capabilities.textDocument?.completion?.completionItem?.snippetSupport);
     return {
       capabilities: {
         textDocumentSync: import_node.TextDocumentSyncKind.Incremental,
@@ -30937,7 +30997,7 @@ var startLanguageServer = (connection, reader) => {
     connection.console.info("Stan language server is exiting...");
   });
   let globalSettings = defaultSettings;
-  let documentSettings = new Map;
+  const documentSettings = new Map;
   connection.onDidChangeConfiguration((change) => {
     if (hasDynamicConfigurationRequestCapability) {
       documentSettings.clear();
@@ -30951,11 +31011,11 @@ var startLanguageServer = (connection, reader) => {
     if (!hasConfigurationCapability) {
       return Promise.resolve(globalSettings);
     }
-    let result = documentSettings.get(resource);
+    const result = documentSettings.get(resource);
     if (result !== undefined) {
       return result;
     }
-    let clientSettings = await connection.workspace.getConfiguration({
+    const clientSettings = await connection.workspace.getConfiguration({
       scopeUri: resource,
       section: SERVER_ID
     }) || {};
@@ -30965,7 +31025,7 @@ var startLanguageServer = (connection, reader) => {
   };
   const documents = new import_node.TextDocuments(TextDocument);
   connection.onCompletion((params) => {
-    return handleCompletion(params, documents);
+    return handleCompletion(params, documents, hasSnippetSupport);
   });
   const getWorkspaceFolders = async () => {
     if (hasWorkspaceFolderCapability) {
@@ -31001,7 +31061,7 @@ var startLanguageServer = (connection, reader) => {
   });
   connection.onHover((params) => {
     const document = documents.get(params.textDocument.uri);
-    if (!document) {
+    if (!document || !document.languageId.startsWith("stan")) {
       return null;
     }
     return hover_default(document, params);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stan-language-server-bin",
-  "version": "0.4.5",
+  "version": "0.4.7",
   "description": "CLI distribution of the Stan language server",
   "bin": {
     "stan-language-server": "bin/cli.js"