@actions/languageserver 0.3.42 → 0.3.43

package/dist/cli.bundle.cjs

@@ -22291,6 +22291,16 @@ function walkTreeToFindStatusFunctionCalls(tree) {
   }
   return false;
 }
+function validateRunsIfCondition(context, token, condition) {
+  const allowedContext = token.definitionInfo?.allowedContext || [];
+  try {
+    ExpressionToken.validateExpression(condition, allowedContext);
+  } catch (err) {
+    context.error(token, err);
+    return void 0;
+  }
+  return condition;
+}
 
 // ../workflow-parser/dist/model/converter/container.js
 function convertToJobContainer(context, container) {
@@ -24992,7 +25002,7 @@ function convertRuns(context, token) {
         break;
       case "pre-if":
         if (isString(item.value)) {
-          preIf = item.value.value;
+          preIf = validateRunsIfCondition(context, item.value, item.value.value);
         }
         break;
       case "post":
@@ -25002,7 +25012,7 @@ function convertRuns(context, token) {
         break;
       case "post-if":
         if (isString(item.value)) {
-          postIf = item.value.value;
+          postIf = validateRunsIfCondition(context, item.value, item.value.value);
         }
         break;
       case "pre-entrypoint":
@@ -27130,6 +27140,12 @@ async function validateAction(textDocument, config) {
     if (!result) {
       return [];
     }
+    let template;
+    if (result.value) {
+      template = getOrConvertActionTemplate(result.context, result.value, textDocument.uri, {
+        errorPolicy: ErrorPolicy.TryConversion
+      });
+    }
     const schemaErrors = result.context.errors.getErrors();
     if (result.value) {
       diagnostics.push(...validateRunsKeysAndFilterErrors(result.value, schemaErrors));
@@ -27146,11 +27162,8 @@ async function validateAction(textDocument, config) {
         severity
       });
     }
-    if (result.value) {
-      const template = getOrConvertActionTemplate(result.context, result.value, textDocument.uri, {
-        errorPolicy: ErrorPolicy.TryConversion
-      });
-      if (template?.runs?.using === "composite") {
+    if (result.value && template) {
+      if (template.runs?.using === "composite") {
         const steps = template.runs.steps ?? [];
         const stepsSequence = findStepsSequence(result.value);
         if (stepsSequence) {
@@ -27161,39 +27174,66 @@ async function validateAction(textDocument, config) {
               await validateActionReference(diagnostics, stepToken, step, config);
             }
             if (isMapping(stepToken)) {
-              validateCompositeStepTokens(diagnostics, stepToken);
+              validateStepUsesField(diagnostics, stepToken);
             }
           }
         }
       }
-      const runsMapping = findRunsMapping(result.value);
-      if (runsMapping) {
-        validateRunsIfConditions(diagnostics, runsMapping);
-      }
-      validateAllExpressions(diagnostics, result.value);
+      validateAllTokens(diagnostics, result.value);
     }
   } catch (e) {
     error(`Unhandled error while validating action file: ${e.message}`);
   }
   return diagnostics;
 }
-function validateCompositeStepTokens(diagnostics, stepToken) {
+function validateStepUsesField(diagnostics, stepToken) {
   for (let i = 0; i < stepToken.count; i++) {
     const { key, value } = stepToken.get(i);
     const keyStr = isString(key) ? key.value.toLowerCase() : "";
     if (keyStr === "uses" && isString(value)) {
       validateStepUsesFormat(diagnostics, value);
     }
-    if (keyStr === "if" && value.range) {
-      if (isString(value)) {
-        validateIfCondition(diagnostics, value);
-      } else if (isBasicExpression(value)) {
-        validateIfConditionExpression(diagnostics, value);
+  }
+}
+function validateAllTokens(diagnostics, root) {
+  for (const [parent, token] of TemplateToken.traverse(root)) {
+    const definitionKey = token.definition?.key;
+    if (token instanceof BasicExpressionToken && token.range) {
+      if (definitionKey === "step-if") {
+        validateIfLiteralText(diagnostics, token);
+      }
+      for (const expression of token.originalExpressions || [token]) {
+        validateExpressionFormatCalls(diagnostics, expression);
+      }
+      if (definitionKey === "runs-if" && parent instanceof MappingToken) {
+        let keyName;
+        for (let i = 0; i < parent.count; i++) {
+          const { key, value } = parent.get(i);
+          if (value === token) {
+            keyName = key.toString().toLowerCase();
+            break;
+          }
+        }
+        if (keyName) {
+          diagnostics.push({
+            message: `Explicit expression syntax \${{ }} is not supported for '${keyName}'. Remove the \${{ }} markers and use the expression directly.`,
+            range: mapRange(token.range),
+            severity: import_vscode_languageserver_types6.DiagnosticSeverity.Error,
+            code: "explicit-expression-not-allowed"
+          });
+        }
+      }
+    }
+    if (isString(token) && token.range) {
+      if (definitionKey === "step-if" || definitionKey === "runs-if") {
+        validateImplicitIfCondition(diagnostics, token);
       }
     }
   }
 }
-function validateIfCondition(diagnostics, token) {
+var LITERAL_TEXT_IN_CONDITION_MESSAGE = "Conditional expression contains literal text outside replacement tokens. This will cause the expression to always evaluate to truthy. Did you mean to put the entire expression inside ${{ }}?";
+var LITERAL_TEXT_IN_CONDITION_CODE = "expression-literal-text-in-condition";
+function validateImplicitIfCondition(diagnostics, token) {
   const condition = token.value.trim();
   if (!condition) {
     return;
@@ -27201,25 +27241,24 @@ function validateIfCondition(diagnostics, token) {
   const allowedContext = token.definitionInfo?.allowedContext || [];
   const { namedContexts, functions } = splitAllowedContext(allowedContext);
   const finalCondition = ensureStatusFunction(condition, token.definitionInfo);
-  const expressionToken = new BasicExpressionToken(token.file, token.range, finalCondition, token.definitionInfo, void 0, token.source, void 0, token.blockScalarHeader);
   try {
-    const l = new Lexer(expressionToken.expression);
+    const l = new Lexer(finalCondition);
     const lr = l.lex();
     const p = new Parser(lr.tokens, namedContexts, functions);
     const expr = p.parse();
     if (hasFormatWithLiteralText(expr)) {
       diagnostics.push({
-        message: "Conditional expression contains literal text outside replacement tokens. This will cause the expression to always evaluate to truthy. Did you mean to put the entire expression inside ${{ }}?",
+        message: LITERAL_TEXT_IN_CONDITION_MESSAGE,
         range: mapRange(token.range),
         severity: import_vscode_languageserver_types6.DiagnosticSeverity.Error,
-        code: "expression-literal-text-in-condition"
+        code: LITERAL_TEXT_IN_CONDITION_CODE
       });
     }
     validateFormatCallsAndAddDiagnostics(diagnostics, expr, token.range);
   } catch {
   }
 }
-function validateIfConditionExpression(diagnostics, token) {
+function validateIfLiteralText(diagnostics, token) {
   const allowedContext = token.definitionInfo?.allowedContext || [];
   const { namedContexts, functions } = splitAllowedContext(allowedContext);
   try {
@@ -27229,15 +27268,27 @@ function validateIfConditionExpression(diagnostics, token) {
     const expr = p.parse();
     if (hasFormatWithLiteralText(expr)) {
       diagnostics.push({
-        message: "Conditional expression contains literal text outside replacement tokens. This will cause the expression to always evaluate to truthy. Did you mean to put the entire expression inside ${{ }}?",
+        message: LITERAL_TEXT_IN_CONDITION_MESSAGE,
         range: mapRange(token.range),
         severity: import_vscode_languageserver_types6.DiagnosticSeverity.Error,
-        code: "expression-literal-text-in-condition"
+        code: LITERAL_TEXT_IN_CONDITION_CODE
       });
     }
   } catch {
   }
 }
+function validateExpressionFormatCalls(diagnostics, token) {
+  const allowedContext = token.definitionInfo?.allowedContext || [];
+  const { namedContexts, functions } = splitAllowedContext(allowedContext);
+  try {
+    const l = new Lexer(token.expression);
+    const lr = l.lex();
+    const p = new Parser(lr.tokens, namedContexts, functions);
+    const expr = p.parse();
+    validateFormatCallsAndAddDiagnostics(diagnostics, expr, token.range);
+  } catch {
+  }
+}
 function validateFormatCallsAndAddDiagnostics(diagnostics, expr, range) {
   const formatErrors = validateFormatCalls(expr);
   for (const formatError of formatErrors) {
@@ -27266,53 +27317,6 @@ function findStepsSequence(root) {
   }
   return void 0;
 }
-function findRunsMapping(root) {
-  if (root instanceof MappingToken) {
-    for (let i = 0; i < root.count; i++) {
-      const { key, value } = root.get(i);
-      if (key.toString().toLowerCase() === "runs" && value instanceof MappingToken) {
-        return value;
-      }
-    }
-  }
-  return void 0;
-}
-function validateRunsIfConditions(diagnostics, runsMapping) {
-  for (let i = 0; i < runsMapping.count; i++) {
-    const { key, value } = runsMapping.get(i);
-    const keyStr = key.toString().toLowerCase();
-    if ((keyStr === "pre-if" || keyStr === "post-if") && value.range) {
-      if (isString(value)) {
-        validateIfCondition(diagnostics, value);
-      } else if (isBasicExpression(value)) {
-        diagnostics.push({
-          message: `Explicit expression syntax \${{ }} is not supported for '${keyStr}'. Remove the \${{ }} markers and use the expression directly.`,
-          range: mapRange(value.range),
-          severity: import_vscode_languageserver_types6.DiagnosticSeverity.Error,
-          code: "explicit-expression-not-allowed"
-        });
-      }
-    }
-  }
-}
-function validateAllExpressions(diagnostics, root) {
-  for (const [, token] of TemplateToken.traverse(root)) {
-    if (token instanceof BasicExpressionToken) {
-      for (const expression of token.originalExpressions || [token]) {
-        const allowedContext = expression.definitionInfo?.allowedContext || [];
-        const { namedContexts, functions } = splitAllowedContext(allowedContext);
-        try {
-          const l = new Lexer(expression.expression);
-          const lr = l.lex();
-          const p = new Parser(lr.tokens, namedContexts, functions);
-          const expr = p.parse();
-          validateFormatCallsAndAddDiagnostics(diagnostics, expr, expression.range);
-        } catch {
-        }
-      }
-    }
-  }
-}
 function validateRunsKeysAndFilterErrors(root, schemaErrors) {
   const diagnostics = [];
   let runsMapping;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@actions/languageserver",
-  "version": "0.3.42",
+  "version": "0.3.43",
   "description": "Language server for GitHub Actions",
   "license": "MIT",
   "type": "module",
@@ -48,8 +48,8 @@
     "actions-languageserver": "./bin/actions-languageserver"
   },
   "dependencies": {
-    "@actions/languageservice": "^0.3.42",
-    "@actions/workflow-parser": "^0.3.42",
+    "@actions/languageservice": "^0.3.43",
+    "@actions/workflow-parser": "^0.3.43",
     "@octokit/rest": "^21.1.1",
     "@octokit/types": "^9.0.0",
     "vscode-languageserver": "^8.0.2",
@@ -78,5 +78,5 @@
     "ts-jest": "^29.0.3",
     "typescript": "^4.8.4"
   },
-  "gitHead": "46b216a6dce39b5cc60bce9325785545fdbaba00"
+  "gitHead": "448180bd7fb42b32566d50239638e51ad8ee78d2"
 }