@herb-tools/language-server 0.9.0 → 0.9.1

package/dist/index.cjs

@@ -4,15 +4,15 @@ var node = require('vscode-languageserver/node');
 var config = require('@herb-tools/config');
 var formatter = require('@herb-tools/formatter');
 var vscodeLanguageserverTextdocument = require('vscode-languageserver-textdocument');
-var core = require('@herb-tools/core');
 var nodeWasm = require('@herb-tools/node-wasm');
 var linter = require('@herb-tools/linter');
 var loader = require('@herb-tools/linter/loader');
 var loader$1 = require('@herb-tools/rewriter/loader');
+var core = require('@herb-tools/core');
 var printer = require('@herb-tools/printer');
 var rewriter = require('@herb-tools/rewriter');
 
-var version = "0.9.0";
+var version = "0.9.1";
 
 class Settings {
     constructor(params, connection) {
@@ -139,6 +139,48 @@ class DocumentService {
     }
 }
 
+class Diagnostics {
+    constructor(connection, documentService, parserService, linterService, configService) {
+        this.diagnostics = new Map();
+        this.connection = connection;
+        this.documentService = documentService;
+        this.parserService = parserService;
+        this.linterService = linterService;
+        this.configService = configService;
+    }
+    async validate(textDocument) {
+        let allDiagnostics = [];
+        if (textDocument.uri.endsWith('.herb.yml')) {
+            allDiagnostics = await this.configService.validateDocument(textDocument);
+        }
+        else {
+            const parseResult = this.parserService.parseDocument(textDocument);
+            const lintResult = await this.linterService.lintDocument(textDocument);
+            allDiagnostics = [
+                ...parseResult.diagnostics,
+                ...lintResult.diagnostics,
+            ];
+        }
+        this.diagnostics.set(textDocument, allDiagnostics);
+        this.sendDiagnosticsFor(textDocument);
+    }
+    async refreshDocument(document) {
+        await this.validate(document);
+    }
+    async refreshAllDocuments() {
+        const documents = this.documentService.getAll();
+        await Promise.all(documents.map(document => this.refreshDocument(document)));
+    }
+    sendDiagnosticsFor(textDocument) {
+        const diagnostics = this.diagnostics.get(textDocument) || [];
+        this.connection.sendDiagnostics({
+            uri: textDocument.uri,
+            diagnostics,
+        });
+        this.diagnostics.delete(textDocument);
+    }
+}
+
 function lspPosition(herbPosition) {
     return node.Position.create(herbPosition.line - 1, herbPosition.column);
 }
@@ -203,265 +245,6 @@ function getFullDocumentRange(document) {
     };
 }
 
-class Diagnostics {
-    constructor(connection, documentService, parserService, linterService, configService) {
-        this.diagnostics = new Map();
-        this.connection = connection;
-        this.documentService = documentService;
-        this.parserService = parserService;
-        this.linterService = linterService;
-        this.configService = configService;
-    }
-    async validate(textDocument) {
-        let allDiagnostics = [];
-        if (textDocument.uri.endsWith('.herb.yml')) {
-            allDiagnostics = await this.configService.validateDocument(textDocument);
-        }
-        else {
-            const parseResult = this.parserService.parseDocument(textDocument);
-            const lintResult = await this.linterService.lintDocument(textDocument);
-            const unreachableCodeDiagnostics = this.getUnreachableCodeDiagnostics(parseResult.document);
-            allDiagnostics = [
-                ...parseResult.diagnostics,
-                ...lintResult.diagnostics,
-                ...unreachableCodeDiagnostics,
-            ];
-        }
-        this.diagnostics.set(textDocument, allDiagnostics);
-        this.sendDiagnosticsFor(textDocument);
-    }
-    getUnreachableCodeDiagnostics(document) {
-        const collector = new UnreachableCodeCollector();
-        collector.visit(document);
-        return collector.diagnostics;
-    }
-    async refreshDocument(document) {
-        await this.validate(document);
-    }
-    async refreshAllDocuments() {
-        const documents = this.documentService.getAll();
-        await Promise.all(documents.map(document => this.refreshDocument(document)));
-    }
-    sendDiagnosticsFor(textDocument) {
-        const diagnostics = this.diagnostics.get(textDocument) || [];
-        this.connection.sendDiagnostics({
-            uri: textDocument.uri,
-            diagnostics,
-        });
-        this.diagnostics.delete(textDocument);
-    }
-}
-class UnreachableCodeCollector extends core.Visitor {
-    constructor() {
-        super(...arguments);
-        this.diagnostics = [];
-        this.processedIfNodes = new Set();
-        this.processedElseNodes = new Set();
-    }
-    visitERBCaseNode(node) {
-        this.checkUnreachableChildren(node.children);
-        this.checkAndMarkElseClause(node.else_clause);
-        this.visitChildNodes(node);
-    }
-    visitERBCaseMatchNode(node) {
-        this.checkUnreachableChildren(node.children);
-        this.checkAndMarkElseClause(node.else_clause);
-        this.visitChildNodes(node);
-    }
-    visitERBIfNode(node) {
-        if (this.processedIfNodes.has(node)) {
-            return;
-        }
-        this.markIfChainAsProcessed(node);
-        this.markElseNodesInIfChain(node);
-        const entireChainEmpty = this.isEntireIfChainEmpty(node);
-        if (entireChainEmpty) {
-            this.checkEmptyStatements(node, node.statements, "if");
-        }
-        else {
-            this.checkIfChainParts(node);
-        }
-        this.visitChildNodes(node);
-    }
-    visitERBElseNode(node) {
-        if (this.processedElseNodes.has(node)) {
-            this.visitChildNodes(node);
-            return;
-        }
-        this.checkEmptyStatements(node, node.statements, "else");
-        this.visitChildNodes(node);
-    }
-    visitERBUnlessNode(node) {
-        const unlessHasContent = this.statementsHaveContent(node.statements);
-        const elseHasContent = node.else_clause && this.statementsHaveContent(node.else_clause.statements);
-        if (node.else_clause) {
-            this.processedElseNodes.add(node.else_clause);
-        }
-        const entireBlockEmpty = !unlessHasContent && !elseHasContent;
-        if (entireBlockEmpty) {
-            this.checkEmptyStatements(node, node.statements, "unless");
-        }
-        else {
-            if (!unlessHasContent) {
-                this.checkEmptyStatementsWithEndLocation(node, node.statements, "unless", node.else_clause);
-            }
-            if (node.else_clause && !elseHasContent) {
-                this.checkEmptyStatements(node.else_clause, node.else_clause.statements, "else");
-            }
-        }
-        this.visitChildNodes(node);
-    }
-    visitERBForNode(node) {
-        this.checkEmptyStatements(node, node.statements, "for");
-        this.visitChildNodes(node);
-    }
-    visitERBWhileNode(node) {
-        this.checkEmptyStatements(node, node.statements, "while");
-        this.visitChildNodes(node);
-    }
-    visitERBUntilNode(node) {
-        this.checkEmptyStatements(node, node.statements, "until");
-        this.visitChildNodes(node);
-    }
-    visitERBWhenNode(node) {
-        if (!node.then_keyword) {
-            this.checkEmptyStatements(node, node.statements, "when");
-        }
-        this.visitChildNodes(node);
-    }
-    visitERBBeginNode(node) {
-        this.checkEmptyStatements(node, node.statements, "begin");
-        this.visitChildNodes(node);
-    }
-    visitERBRescueNode(node) {
-        this.checkEmptyStatements(node, node.statements, "rescue");
-        this.visitChildNodes(node);
-    }
-    visitERBEnsureNode(node) {
-        this.checkEmptyStatements(node, node.statements, "ensure");
-        this.visitChildNodes(node);
-    }
-    visitERBBlockNode(node) {
-        this.checkEmptyStatements(node, node.body, "block");
-        this.visitChildNodes(node);
-    }
-    visitERBInNode(node) {
-        if (!node.then_keyword) {
-            this.checkEmptyStatements(node, node.statements, "in");
-        }
-        this.visitChildNodes(node);
-    }
-    checkUnreachableChildren(children) {
-        for (const child of children) {
-            if (core.isHTMLTextNode(child) && child.content.trim() === "") {
-                continue;
-            }
-            this.addDiagnostic(child.location, "Unreachable code: content between case and when/in is never executed");
-        }
-    }
-    checkEmptyStatements(node, statements, blockType) {
-        this.checkEmptyStatementsWithEndLocation(node, statements, blockType, null);
-    }
-    checkEmptyStatementsWithEndLocation(node, statements, blockType, subsequentNode) {
-        if (this.statementsHaveContent(statements)) {
-            return;
-        }
-        const startLocation = node.location.start;
-        const endLocation = subsequentNode
-            ? subsequentNode.location.start
-            : node.location.end;
-        this.addDiagnostic({ start: startLocation, end: endLocation }, `Empty ${blockType} block: this control flow statement has no content`);
-    }
-    addDiagnostic(location, message) {
-        const diagnostic = {
-            range: lspRangeFromLocation(location),
-            message,
-            severity: node.DiagnosticSeverity.Hint,
-            tags: [node.DiagnosticTag.Unnecessary],
-            source: "Herb Language Server"
-        };
-        this.diagnostics.push(diagnostic);
-    }
-    statementsHaveContent(statements) {
-        return statements.some(statement => {
-            if (core.isHTMLTextNode(statement)) {
-                return statement.content.trim() !== "";
-            }
-            return true;
-        });
-    }
-    checkAndMarkElseClause(elseClause) {
-        if (!elseClause) {
-            return;
-        }
-        this.processedElseNodes.add(elseClause);
-        if (!this.statementsHaveContent(elseClause.statements)) {
-            this.checkEmptyStatements(elseClause, elseClause.statements, "else");
-        }
-    }
-    markIfChainAsProcessed(node) {
-        this.processedIfNodes.add(node);
-        this.traverseSubsequentNodes(node.subsequent, (current) => {
-            if (core.isERBIfNode(current)) {
-                this.processedIfNodes.add(current);
-            }
-        });
-    }
-    markElseNodesInIfChain(node) {
-        this.traverseSubsequentNodes(node.subsequent, (current) => {
-            if (core.isERBElseNode(current)) {
-                this.processedElseNodes.add(current);
-            }
-        });
-    }
-    traverseSubsequentNodes(startNode, callback) {
-        let current = startNode;
-        while (current) {
-            if (core.isERBIfNode(current)) {
-                callback(current);
-                current = current.subsequent;
-            }
-            else if (core.isERBElseNode(current)) {
-                callback(current);
-                break;
-            }
-            else {
-                break;
-            }
-        }
-    }
-    checkIfChainParts(node) {
-        if (!this.statementsHaveContent(node.statements)) {
-            this.checkEmptyStatementsWithEndLocation(node, node.statements, "if", node.subsequent);
-        }
-        this.traverseSubsequentNodes(node.subsequent, (current) => {
-            if (this.statementsHaveContent(current.statements)) {
-                return;
-            }
-            const blockType = core.isERBIfNode(current) ? 'elsif' : 'else';
-            const nextSubsequent = core.isERBIfNode(current) ? current.subsequent : null;
-            if (nextSubsequent) {
-                this.checkEmptyStatementsWithEndLocation(current, current.statements, blockType, nextSubsequent);
-            }
-            else {
-                this.checkEmptyStatements(current, current.statements, blockType);
-            }
-        });
-    }
-    isEntireIfChainEmpty(node) {
-        if (this.statementsHaveContent(node.statements)) {
-            return false;
-        }
-        let hasContent = false;
-        this.traverseSubsequentNodes(node.subsequent, (current) => {
-            if (this.statementsHaveContent(current.statements)) {
-                hasContent = true;
-            }
-        });
-        return !hasContent;
-    }
-}
-
 class ErrorVisitor extends nodeWasm.Visitor {
     constructor() {
         super(...arguments);
@@ -520,6 +303,17 @@ function lintToDignosticSeverity(severity) {
         case "hint": return node.DiagnosticSeverity.Hint;
     }
 }
+function lintToDignosticTags(tags) {
+    if (!tags)
+        return [];
+    return tags.flatMap(tag => {
+        switch (tag) {
+            case "unnecessary": return [node.DiagnosticTag.Unnecessary];
+            case "deprecated": return [node.DiagnosticTag.Deprecated];
+            default: return [];
+        }
+    });
+}
 
 const OPEN_CONFIG_ACTION$1 = 'Open .herb.yml';
 class LinterService {
@@ -651,7 +445,7 @@ class LinterService {
                     ? `file://${customRulePath}`
                     : linter.ruleDocumentationUrl(offense.rule)
             };
-            return {
+            const diagnostic = {
                 source: this.source,
                 severity: lintToDignosticSeverity(offense.severity),
                 range,
@@ -660,6 +454,11 @@ class LinterService {
                 data: { rule: offense.rule },
                 codeDescription
             };
+            const tags = lintToDignosticTags(offense.tags);
+            if (tags.length > 0) {
+                diagnostic.tags = tags;
+            }
+            return diagnostic;
         });
         return { diagnostics };
     }
@@ -2678,6 +2477,9 @@ class Server {
             const document = this.service.documentService.get(params.textDocument.uri);
             if (!document)
                 return [];
+            const parseResult = this.service.parserService.parseDocument(document);
+            if (parseResult.diagnostics.length > 0)
+                return [];
             const diagnostics = params.context.diagnostics;
             const documentText = document.getText();
             const linterDisableCodeActions = this.service.codeActionService.createCodeActions(params.textDocument.uri, diagnostics, documentText);
@@ -2744,7 +2546,6 @@ exports.Project = Project;
 exports.Server = Server;
 exports.Service = Service;
 exports.Settings = Settings;
-exports.UnreachableCodeCollector = UnreachableCodeCollector;
 exports.camelize = camelize;
 exports.capitalize = capitalize;
 exports.dasherize = dasherize;
@@ -2752,6 +2553,7 @@ exports.erbTagToRange = erbTagToRange;
 exports.getFullDocumentRange = getFullDocumentRange;
 exports.isPositionInRange = isPositionInRange;
 exports.lintToDignosticSeverity = lintToDignosticSeverity;
+exports.lintToDignosticTags = lintToDignosticTags;
 exports.lspLine = lspLine;
 exports.lspPosition = lspPosition;
 exports.lspRangeFromLocation = lspRangeFromLocation;