Refactor validation functions in terms of validateNodeBy

Author: neuroevolutus

server/src/server.ts

@@ -309,43 +309,42 @@ export function validateScrapScript(
   text: string,
   maxNumberOfProblems: number,
 ): Diagnostic[] {
-  const diagnostics: Diagnostic[] = [];
-
-  if (text === "") return diagnostics;
+  if (text === "") return [];
 
+  let tree: Tree;
   try {
-    const tree = parse(text);
-    const rootNode = tree.rootNode;
-
-    // Enhanced error detection
-    if (rootNode.hasError) {
-      const errorNodes = findErrorNodes(rootNode);
-
-      for (const errorNode of errorNodes) {
-        const range = nodeToRange(errorNode);
-        const diagnostic = createDiagnosticForError(errorNode, range);
-        diagnostics.push(diagnostic);
-      }
-    }
-
-    // Additional validations
-    validatePatternMatching(rootNode, diagnostics);
-    validateTypeConsistency(rootNode, diagnostics, text);
-    validateWhereClauseStructure(rootNode, diagnostics);
-    validateRecordSyntax(rootNode, diagnostics);
-    validateListSyntax(rootNode, diagnostics);
-    validateFunctionSyntax(rootNode, diagnostics);
+    tree = parse(text);
   } catch (err) {
     console.error("Error parsing ScrapScript:", err);
-    diagnostics.push({
+    return limitDiagnostics([{
       severity: DiagnosticSeverity.Error,
       range: Range.create(0, 0, 0, 0),
       message: `Failed to parse ScrapScript: ${err}`,
       source: "scrapscript",
-    });
+    }], maxNumberOfProblems);
   }
 
-  return diagnostics.slice(0, maxNumberOfProblems);
+  const rootNode: SyntaxNode = tree.rootNode;
+
+  // Enhanced error detection
+  const errors: Diagnostic[] = rootNode.hasError ?
+    findErrorNodes(rootNode).map(errorNode => {
+      const range = nodeToRange(errorNode);
+      return createDiagnosticForError(errorNode, range);
+    }) : [];
+
+  // Additional validations
+  const validations: Diagnostic[] = [
+    validatePatternMatching(rootNode),
+    validateTypeConsistency(rootNode, text),
+    validateWhereClauseStructure(rootNode),
+    validateRecordSyntax(rootNode),
+    validateListSyntax(rootNode),
+    validateFunctionSyntax(rootNode)
+  ].flat();
+
+  const diagnostics: Diagnostic[] = errors.concat(validations);
+  return limitDiagnostics(diagnostics, maxNumberOfProblems);
 }
 
 function findErrorNodes(node: SyntaxNode): SyntaxNode[] {
@@ -414,11 +413,9 @@ function createDiagnosticForError(
   };
 }
 
-function validatePatternMatching(
-  node: SyntaxNode,
-  diagnostics: Diagnostic[],
-): void {
-  walkTree(node, (currentNode) => {
+function validatePatternMatching(node: SyntaxNode): Diagnostic[] {
+  return validateNodeBy(node, (currentNode) => {
+    let diagnostics: Diagnostic[] = [];
     if (
       currentNode.type === "match_fun" ||
       currentNode.type === "pattern_match"
@@ -454,15 +451,16 @@ function validatePatternMatching(
         });
       }
     }
+    return diagnostics;
   });
 }
 
 function validateTypeConsistency(
   node: SyntaxNode,
-  diagnostics: Diagnostic[],
   text: string,
-): void {
-  walkTree(node, (currentNode) => {
+): Diagnostic[] {
+  return validateNodeBy(node, (currentNode) => {
+    let diagnostics: Diagnostic[] = [];
     if (currentNode.type === "list") {
       const elementTypes = new Set<string>();
 
@@ -485,6 +483,7 @@ function validateTypeConsistency(
         });
       }
     }
+    return diagnostics;
   });
 }
 
@@ -512,11 +511,9 @@ function inferBasicType(node: SyntaxNode): string | null {
   }
 }
 
-function validateWhereClauseStructure(
-  node: SyntaxNode,
-  diagnostics: Diagnostic[],
-): void {
-  walkTree(node, (currentNode) => {
+function validateWhereClauseStructure(node: SyntaxNode): Diagnostic[] {
+  return validateNodeBy(node, (currentNode) => {
+    let diagnostics: Diagnostic[] = [];
     if (currentNode.type === "where") {
       // Check for proper "; identifier = expression" structure
       let hasProperStructure = false;
@@ -543,14 +540,13 @@ function validateWhereClauseStructure(
         });
       }
     }
+    return diagnostics;
   });
 }
 
-function validateRecordSyntax(
-  node: SyntaxNode,
-  diagnostics: Diagnostic[],
-): void {
-  walkTree(node, (currentNode) => {
+function validateRecordSyntax(node: SyntaxNode): Diagnostic[] {
+  return validateNodeBy(node, (currentNode) => {
+    let diagnostics: Diagnostic[] = [];
     if (currentNode.type === "record") {
       // Validate record field syntax
       for (let i = 0; i < currentNode.namedChildCount; i++) {
@@ -569,11 +565,13 @@ function validateRecordSyntax(
         }
       }
     }
+    return diagnostics;
   });
 }
 
-function validateListSyntax(node: SyntaxNode, diagnostics: Diagnostic[]): void {
-  walkTree(node, (currentNode) => {
+function validateListSyntax(node: SyntaxNode): Diagnostic[] {
+  return validateNodeBy(node, (currentNode) => {
+    let diagnostics: Diagnostic[] = [];
     if (currentNode.type === "list") {
       // Check for trailing commas and proper separators
       const text = currentNode.text;
@@ -587,14 +585,13 @@ function validateListSyntax(node: SyntaxNode, diagnostics: Diagnostic[]): void {
         });
       }
     }
+    return diagnostics;
   });
 }
 
-function validateFunctionSyntax(
-  node: SyntaxNode,
-  diagnostics: Diagnostic[],
-): void {
-  walkTree(node, (currentNode) => {
+function validateFunctionSyntax(node: SyntaxNode): Diagnostic[] {
+  return validateNodeBy(node, (currentNode) => {
+    let diagnostics: Diagnostic[] = [];
     if (currentNode.type === "fun") {
       // Check for proper arrow function syntax
       const hasArrow = currentNode.text.includes("->");
@@ -608,6 +605,7 @@ function validateFunctionSyntax(
         });
       }
     }
+    return diagnostics;
   });
 }