yukigo 0.2.0 → 0.2.2

package/dist/src/analyzer/inspections/generic/smells.js

@@ -0,0 +1,349 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { BooleanPrimitive, Call, Function, NilPrimitive, Return, Sequence, StopTraversalException, SymbolPrimitive, Variable, } from "yukigo-ast";
+import { AutoScoped, ScopedVisitor } from "../../utils.js";
+function isSequenceEmpty(node) {
+    return node instanceof Sequence && node.statements.length === 0;
+}
+/**
+ * Basic Levenshtein distance for typo detection
+ */
+function getLevenshteinDistance(a, b) {
+    const matrix = [];
+    for (let i = 0; i <= b.length; i++)
+        matrix[i] = [i];
+    for (let j = 0; j <= a.length; j++)
+        matrix[0][j] = j;
+    for (let i = 1; i <= b.length; i++) {
+        for (let j = 1; j <= a.length; j++) {
+            if (b.charAt(i - 1) === a.charAt(j - 1)) {
+                matrix[i][j] = matrix[i - 1][j - 1];
+            }
+            else {
+                matrix[i][j] = Math.min(matrix[i - 1][j - 1] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j] + 1);
+            }
+        }
+    }
+    return matrix[b.length][a.length];
+}
+let DiscardsExceptions = class DiscardsExceptions extends ScopedVisitor {
+    visitCatch(node) {
+        if (!node.body ||
+            node.body instanceof NilPrimitive ||
+            isSequenceEmpty(node.body)) {
+            throw new StopTraversalException();
+        }
+    }
+};
+DiscardsExceptions = __decorate([
+    AutoScoped
+], DiscardsExceptions);
+export { DiscardsExceptions };
+let DoesConsolePrint = class DoesConsolePrint extends ScopedVisitor {
+    visitPrint(node) {
+        throw new StopTraversalException();
+    }
+    visitCall(node) {
+        const name = node.callee.value;
+        if (this.isPrintFunc(name))
+            throw new StopTraversalException();
+    }
+    visitApplication(node) {
+        const func = node.functionExpr;
+        if (!(func instanceof SymbolPrimitive))
+            return func.accept(this);
+        const name = func.value;
+        if (this.isPrintFunc(name))
+            throw new StopTraversalException();
+    }
+    isPrintFunc(name) {
+        const printFuncs = [
+            "print",
+            "println",
+            "puts",
+            "log",
+            "console.log",
+            "System.out.println",
+            "fmt.Println",
+        ];
+        if (printFuncs.includes(name))
+            return true;
+        return false;
+    }
+};
+DoesConsolePrint = __decorate([
+    AutoScoped
+], DoesConsolePrint);
+export { DoesConsolePrint };
+let HasDeclarationTypos = class HasDeclarationTypos extends ScopedVisitor {
+    /*
+     * Checks if two variables declared in the same scope are suspiciously similar
+     * (Levenshtein distance <= 2), indicating a possible typo (e.g., 'count' vs 'conut').
+     */
+    visitSequence(node) {
+        const declaredNames = [];
+        for (const stmt of node.statements) {
+            if (stmt instanceof Variable)
+                declaredNames.push(stmt.identifier.value);
+        }
+        for (let i = 0; i < declaredNames.length; i++) {
+            for (let j = i + 1; j < declaredNames.length; j++) {
+                const a = declaredNames[i];
+                const b = declaredNames[j];
+                if (a.length > 3 && b.length > 3) {
+                    if (getLevenshteinDistance(a, b) <= 2) {
+                        throw new StopTraversalException();
+                    }
+                }
+            }
+        }
+    }
+};
+HasDeclarationTypos = __decorate([
+    AutoScoped
+], HasDeclarationTypos);
+export { HasDeclarationTypos };
+let HasEmptyIfBranches = class HasEmptyIfBranches extends ScopedVisitor {
+    visitIf(node) {
+        const isThenEmpty = !node.then || isSequenceEmpty(node.then);
+        const isElseEmpty = node.elseExpr && isSequenceEmpty(node.elseExpr);
+        if (isThenEmpty || isElseEmpty)
+            throw new StopTraversalException();
+    }
+};
+HasEmptyIfBranches = __decorate([
+    AutoScoped
+], HasEmptyIfBranches);
+export { HasEmptyIfBranches };
+let HasLongParameterList = class HasLongParameterList extends ScopedVisitor {
+    maxParams;
+    constructor(maxParams = 5, scope) {
+        super(scope);
+        this.maxParams = Number(maxParams);
+    }
+    visitEquation(node) {
+        const params = node.patterns;
+        if (params.length > this.maxParams)
+            throw new StopTraversalException();
+    }
+};
+HasLongParameterList = __decorate([
+    AutoScoped
+], HasLongParameterList);
+export { HasLongParameterList };
+let HasMisspelledIdentifiers = class HasMisspelledIdentifiers extends ScopedVisitor {
+    dictionary;
+    constructor(dictionaryWords = [], scope) {
+        super(scope);
+        // In a real app, load a standard dictionary + jargon here
+        this.dictionary = new Set(dictionaryWords.map((w) => w.toLowerCase()));
+    }
+    visitVariable(node) {
+        this.checkSpelling(node.identifier.value);
+    }
+    visitFunction(node) {
+        this.checkSpelling(node.identifier.value);
+    }
+    checkSpelling(word) {
+        // Skip if no dictionary provided or word is very short
+        if (this.dictionary.size === 0 || word.length < 3)
+            return;
+        // Naive camelCase splitter
+        const parts = word.split(/(?=[A-Z])|[-_]/);
+        for (const part of parts) {
+            if (!this.dictionary.has(part.toLowerCase()))
+                throw new StopTraversalException();
+        }
+    }
+};
+HasMisspelledIdentifiers = __decorate([
+    AutoScoped
+], HasMisspelledIdentifiers);
+export { HasMisspelledIdentifiers };
+let HasRedundantBooleanComparison = class HasRedundantBooleanComparison extends ScopedVisitor {
+    visitLogicalBinaryOperation(node) {
+        const isLeftBool = node.left instanceof BooleanPrimitive;
+        const isRightBool = node.right instanceof BooleanPrimitive;
+        if (isLeftBool || isRightBool)
+            throw new StopTraversalException();
+    }
+};
+HasRedundantBooleanComparison = __decorate([
+    AutoScoped
+], HasRedundantBooleanComparison);
+export { HasRedundantBooleanComparison };
+let HasRedundantIf = class HasRedundantIf extends ScopedVisitor {
+    visitIf(node) {
+        if (node.elseExpr) {
+            const thenStmt = node.then;
+            const elseStmt = node.elseExpr;
+            if (thenStmt instanceof Sequence && elseStmt instanceof Sequence) {
+                // Check if returning booleans
+                if (thenStmt.statements.some((stmt) => stmt instanceof BooleanPrimitive) &&
+                    elseStmt.statements.some((stmt) => stmt instanceof BooleanPrimitive)) {
+                    throw new StopTraversalException();
+                }
+            }
+        }
+    }
+};
+HasRedundantIf = __decorate([
+    AutoScoped
+], HasRedundantIf);
+export { HasRedundantIf };
+let HasRedundantLocalVariableReturn = class HasRedundantLocalVariableReturn extends ScopedVisitor {
+    /*
+     * Detects:
+     * var x = something;
+     * return x;
+     */
+    visitSequence(node) {
+        const stmts = node.statements;
+        for (let i = 0; i < stmts.length - 1; i++) {
+            const stmt = stmts[i];
+            const nextStmt = stmts[i + 1];
+            if (stmt instanceof Variable && nextStmt instanceof Return) {
+                if (nextStmt.body instanceof SymbolPrimitive &&
+                    nextStmt.body.value === stmt.identifier.value) {
+                    throw new StopTraversalException();
+                }
+            }
+        }
+    }
+};
+HasRedundantLocalVariableReturn = __decorate([
+    AutoScoped
+], HasRedundantLocalVariableReturn);
+export { HasRedundantLocalVariableReturn };
+let HasTooShortIdentifiers = class HasTooShortIdentifiers extends ScopedVisitor {
+    minLength;
+    constructor(minLength = 3, scope) {
+        super(scope);
+        this.minLength = Number(minLength);
+    }
+    visitVariable(node) {
+        // exclude common counters
+        const allowed = ["i", "j", "k", "x", "y", "z", "id"];
+        const name = node.identifier.value;
+        if (name.length < this.minLength && !allowed.includes(name)) {
+            throw new StopTraversalException();
+        }
+    }
+};
+HasTooShortIdentifiers = __decorate([
+    AutoScoped
+], HasTooShortIdentifiers);
+export { HasTooShortIdentifiers };
+let HasUsageTypos = class HasUsageTypos extends ScopedVisitor {
+    visitSequence(node) {
+        const declaredNames = new Set();
+        const usedNames = new Set();
+        for (const stmt of node.statements) {
+            if (stmt instanceof Function || stmt instanceof Variable) {
+                declaredNames.add(stmt.identifier.value);
+            }
+        }
+        for (const stmt of node.statements) {
+            if (stmt instanceof Call)
+                usedNames.add(stmt.callee.value);
+        }
+        for (const usage of usedNames) {
+            if (!declaredNames.has(usage)) {
+                for (const decl of declaredNames) {
+                    if (usage.length > 3 && getLevenshteinDistance(usage, decl) <= 1) {
+                        throw new StopTraversalException();
+                    }
+                }
+            }
+        }
+    }
+};
+HasUsageTypos = __decorate([
+    AutoScoped
+], HasUsageTypos);
+export { HasUsageTypos };
+let UsesWrongCaseBindings = class UsesWrongCaseBindings extends ScopedVisitor {
+    caseType;
+    constructor(caseType = "camel", scopeName) {
+        super(scopeName);
+        this.caseType = caseType;
+    }
+    visitSymbolPrimitive(node) {
+        this.checkCase(node.value);
+    }
+    checkCase(name) {
+        // Ignore operators (names not starting with a letter or underscore)
+        if (!/^[a-zA-Z_]/.test(name))
+            return;
+        let regex;
+        switch (this.caseType) {
+            case "snake":
+                regex = /^[a-z][a-z0-9_]*$/;
+                break;
+            case "pascal":
+                regex = /^[A-Z][a-zA-Z0-9]*$/;
+                break;
+            case "camel":
+            default:
+                regex = /^[a-z][a-zA-Z0-9]*$/;
+                break;
+        }
+        if (!regex.test(name)) {
+            throw new StopTraversalException();
+        }
+    }
+};
+UsesWrongCaseBindings = __decorate([
+    AutoScoped
+], UsesWrongCaseBindings);
+export { UsesWrongCaseBindings };
+let IsLongCode = class IsLongCode extends ScopedVisitor {
+    maxStatements;
+    constructor(maxStatements = 50, scopeName) {
+        super(scopeName);
+        this.maxStatements = Number(maxStatements);
+    }
+    visitSequence(node) {
+        if (node.statements.length > this.maxStatements) {
+            throw new StopTraversalException();
+        }
+    }
+};
+IsLongCode = __decorate([
+    AutoScoped
+], IsLongCode);
+export { IsLongCode };
+let ShouldInvertIfCondition = class ShouldInvertIfCondition extends ScopedVisitor {
+    visitIf(node) {
+        const thenEmpty = !node.then || isSequenceEmpty(node.then);
+        const elseNonEmpty = node.elseExpr && !isSequenceEmpty(node.elseExpr);
+        if (thenEmpty && elseNonEmpty) {
+            throw new StopTraversalException();
+        }
+    }
+};
+ShouldInvertIfCondition = __decorate([
+    AutoScoped
+], ShouldInvertIfCondition);
+export { ShouldInvertIfCondition };
+export const genericSmells = {
+    DiscardsExceptions: DiscardsExceptions,
+    DoesConsolePrint: DoesConsolePrint,
+    HasDeclarationTypos: HasDeclarationTypos,
+    HasEmptyIfBranches: HasEmptyIfBranches,
+    HasLongParameterList: HasLongParameterList,
+    HasMisspelledIdentifiers: HasMisspelledIdentifiers,
+    HasRedundantBooleanComparison: HasRedundantBooleanComparison,
+    HasRedundantIf: HasRedundantIf,
+    HasRedundantLocalVariableReturn: HasRedundantLocalVariableReturn,
+    HasTooShortIdentifiers: HasTooShortIdentifiers,
+    HasUsageTypos: HasUsageTypos,
+    HasWrongCaseIdentifiers: UsesWrongCaseBindings,
+    UsesWrongCaseBindings: UsesWrongCaseBindings,
+    IsLongCode: IsLongCode,
+    ShouldInvertIfCondition: ShouldInvertIfCondition,
+};

package/dist/src/analyzer/inspections/imperative/imperative.d.ts

@@ -0,0 +1,35 @@
+import { Enumeration, ForLoop, Procedure, Repeat, Switch, While } from "yukigo-ast";
+import { ScopedVisitor, VisitorConstructor, InspectionVisitor } from "../../utils.js";
+export declare class DeclaresEnumeration extends InspectionVisitor {
+    private readonly enumName;
+    constructor(enumName: string);
+    visitEnumeration(node: Enumeration): void;
+}
+export declare class DeclaresProcedure extends ScopedVisitor {
+    private readonly procedureName;
+    constructor(procedureName: string, scope?: string);
+    visitProcedure(node: Procedure): void;
+}
+export declare class UsesForLoop extends ScopedVisitor {
+    constructor(scope?: string);
+    visitForLoop(node: ForLoop): void;
+}
+export declare class UsesWhile extends ScopedVisitor {
+    constructor(scope?: string);
+    visitWhile(node: While): void;
+}
+export declare class UsesRepeat extends ScopedVisitor {
+    constructor(scope?: string);
+    visitRepeat(node: Repeat): void;
+}
+export declare class UsesLoop extends ScopedVisitor {
+    constructor(scope?: string);
+    visitForLoop(node: ForLoop): void;
+    visitWhile(node: While): void;
+    visitRepeat(node: Repeat): void;
+}
+export declare class UsesSwitch extends ScopedVisitor {
+    constructor(scope?: string);
+    visitSwitch(node: Switch): void;
+}
+export declare const imperativeInspections: Record<string, VisitorConstructor>;

package/dist/src/analyzer/inspections/imperative/imperative.js

@@ -0,0 +1,109 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { StopTraversalException, } from "yukigo-ast";
+import { AutoScoped, ScopedVisitor, InspectionVisitor, } from "../../utils.js";
+export class DeclaresEnumeration extends InspectionVisitor {
+    enumName;
+    constructor(enumName) {
+        super();
+        this.enumName = enumName;
+    }
+    visitEnumeration(node) {
+        if (node.identifier.value === this.enumName)
+            throw new StopTraversalException();
+    }
+}
+let DeclaresProcedure = class DeclaresProcedure extends ScopedVisitor {
+    procedureName;
+    constructor(procedureName, scope) {
+        super(scope);
+        this.procedureName = procedureName;
+    }
+    visitProcedure(node) {
+        if (node.identifier.value === this.procedureName)
+            throw new StopTraversalException();
+    }
+};
+DeclaresProcedure = __decorate([
+    AutoScoped
+], DeclaresProcedure);
+export { DeclaresProcedure };
+let UsesForLoop = class UsesForLoop extends ScopedVisitor {
+    constructor(scope) {
+        super(scope);
+    }
+    visitForLoop(node) {
+        throw new StopTraversalException();
+    }
+};
+UsesForLoop = __decorate([
+    AutoScoped
+], UsesForLoop);
+export { UsesForLoop };
+let UsesWhile = class UsesWhile extends ScopedVisitor {
+    constructor(scope) {
+        super(scope);
+    }
+    visitWhile(node) {
+        throw new StopTraversalException();
+    }
+};
+UsesWhile = __decorate([
+    AutoScoped
+], UsesWhile);
+export { UsesWhile };
+let UsesRepeat = class UsesRepeat extends ScopedVisitor {
+    constructor(scope) {
+        super(scope);
+    }
+    visitRepeat(node) {
+        throw new StopTraversalException();
+    }
+};
+UsesRepeat = __decorate([
+    AutoScoped
+], UsesRepeat);
+export { UsesRepeat };
+let UsesLoop = class UsesLoop extends ScopedVisitor {
+    constructor(scope) {
+        super(scope);
+    }
+    visitForLoop(node) {
+        throw new StopTraversalException();
+    }
+    visitWhile(node) {
+        throw new StopTraversalException();
+    }
+    visitRepeat(node) {
+        throw new StopTraversalException();
+    }
+};
+UsesLoop = __decorate([
+    AutoScoped
+], UsesLoop);
+export { UsesLoop };
+let UsesSwitch = class UsesSwitch extends ScopedVisitor {
+    constructor(scope) {
+        super(scope);
+    }
+    visitSwitch(node) {
+        throw new StopTraversalException();
+    }
+};
+UsesSwitch = __decorate([
+    AutoScoped
+], UsesSwitch);
+export { UsesSwitch };
+export const imperativeInspections = {
+    DeclaresEnumeration: DeclaresEnumeration,
+    DeclaresProcedure: DeclaresProcedure,
+    UsesForLoop: UsesForLoop,
+    UsesRepeat: UsesRepeat,
+    UsesWhile: UsesWhile,
+    UsesLoop: UsesLoop,
+    UsesSwitch: UsesSwitch,
+};

package/dist/src/analyzer/inspections/imperative/smells.d.ts

@@ -0,0 +1,16 @@
+import { If, Repeat, Return, While } from "yukigo-ast";
+import { ScopedVisitor, VisitorConstructor } from "../../utils.js";
+export declare class HasAssignmentCondition extends ScopedVisitor {
+    visitIf(node: If): void;
+    visitWhile(node: While): void;
+}
+export declare class HasAssignmentReturn extends ScopedVisitor {
+    visitReturn(node: Return): void;
+}
+export declare class HasEmptyRepeat extends ScopedVisitor {
+    visitRepeat(node: Repeat): void;
+}
+export declare class HasRedundantRepeat extends ScopedVisitor {
+    visitRepeat(node: Repeat): void;
+}
+export declare const imperativeSmells: Record<string, VisitorConstructor>;

package/dist/src/analyzer/inspections/imperative/smells.js

@@ -0,0 +1,58 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Assignment, NumberPrimitive, Sequence, StopTraversalException, } from "yukigo-ast";
+import { AutoScoped, ScopedVisitor } from "../../utils.js";
+let HasAssignmentCondition = class HasAssignmentCondition extends ScopedVisitor {
+    visitIf(node) {
+        if (node.condition instanceof Assignment)
+            throw new StopTraversalException();
+    }
+    visitWhile(node) {
+        if (node.condition instanceof Assignment)
+            throw new StopTraversalException();
+    }
+};
+HasAssignmentCondition = __decorate([
+    AutoScoped
+], HasAssignmentCondition);
+export { HasAssignmentCondition };
+let HasAssignmentReturn = class HasAssignmentReturn extends ScopedVisitor {
+    visitReturn(node) {
+        if (node.body && node.body instanceof Assignment)
+            throw new StopTraversalException();
+    }
+};
+HasAssignmentReturn = __decorate([
+    AutoScoped
+], HasAssignmentReturn);
+export { HasAssignmentReturn };
+let HasEmptyRepeat = class HasEmptyRepeat extends ScopedVisitor {
+    visitRepeat(node) {
+        if (node.body instanceof Sequence && node.body.statements.length === 0)
+            throw new StopTraversalException();
+    }
+};
+HasEmptyRepeat = __decorate([
+    AutoScoped
+], HasEmptyRepeat);
+export { HasEmptyRepeat };
+let HasRedundantRepeat = class HasRedundantRepeat extends ScopedVisitor {
+    visitRepeat(node) {
+        if (node.count instanceof NumberPrimitive && node.count.value === 1)
+            throw new StopTraversalException();
+    }
+};
+HasRedundantRepeat = __decorate([
+    AutoScoped
+], HasRedundantRepeat);
+export { HasRedundantRepeat };
+export const imperativeSmells = {
+    HasAssignmentCondition: HasAssignmentCondition,
+    HasAssignmentReturn: HasAssignmentReturn,
+    HasEmptyRepeat: HasEmptyRepeat,
+    HasRedundantRepeat: HasRedundantRepeat,
+};

package/dist/src/analyzer/inspections/logic/logic.d.ts

@@ -0,0 +1,32 @@
+import { Exist, Fact, Findall, Forall, Not, Rule } from "yukigo-ast";
+import { ScopedVisitor, VisitorConstructor, InspectionVisitor } from "../../utils.js";
+export declare class DeclaresFact extends InspectionVisitor {
+    private readonly target?;
+    constructor(target?: string | undefined);
+    visitFact(node: Fact): void;
+}
+export declare class DeclaresRule extends InspectionVisitor {
+    private readonly target?;
+    constructor(target?: string | undefined);
+    visitRule(node: Rule): void;
+}
+export declare class DeclaresPredicate extends InspectionVisitor {
+    private readonly target?;
+    constructor(target?: string | undefined);
+    visitFact(node: Fact): void;
+    visitRule(node: Rule): void;
+}
+export declare class UsesFindall extends ScopedVisitor {
+    constructor(scope?: string);
+    visitFindall(node: Findall): void;
+}
+export declare class UsesForall extends ScopedVisitor {
+    constructor(scope?: string);
+    visitForall(node: Forall): void;
+}
+export declare class UsesNot extends ScopedVisitor {
+    constructor(scope?: string);
+    visitNot(node: Not): void;
+    visitExist(node: Exist): void;
+}
+export declare const logicInspections: Record<string, VisitorConstructor>;

package/dist/src/analyzer/inspections/logic/logic.js

@@ -0,0 +1,96 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { StopTraversalException, } from "yukigo-ast";
+import { AutoScoped, ScopedVisitor, InspectionVisitor } from "../../utils.js";
+export class DeclaresFact extends InspectionVisitor {
+    target;
+    constructor(target) {
+        super();
+        this.target = target;
+    }
+    visitFact(node) {
+        const bindingName = node.identifier.value;
+        if (!this.target || bindingName === this.target)
+            throw new StopTraversalException();
+    }
+}
+export class DeclaresRule extends InspectionVisitor {
+    target;
+    constructor(target) {
+        super();
+        this.target = target;
+    }
+    visitRule(node) {
+        const bindingName = node.identifier.value;
+        if (!this.target || bindingName === this.target)
+            throw new StopTraversalException();
+    }
+}
+export class DeclaresPredicate extends InspectionVisitor {
+    target;
+    constructor(target) {
+        super();
+        this.target = target;
+    }
+    visitFact(node) {
+        new DeclaresFact(this.target).visitFact(node);
+    }
+    visitRule(node) {
+        new DeclaresRule(this.target).visitRule(node);
+    }
+}
+let UsesFindall = class UsesFindall extends ScopedVisitor {
+    constructor(scope) {
+        super(scope);
+    }
+    visitFindall(node) {
+        throw new StopTraversalException();
+    }
+};
+UsesFindall = __decorate([
+    AutoScoped
+], UsesFindall);
+export { UsesFindall };
+let UsesForall = class UsesForall extends ScopedVisitor {
+    constructor(scope) {
+        super(scope);
+    }
+    visitForall(node) {
+        throw new StopTraversalException();
+    }
+};
+UsesForall = __decorate([
+    AutoScoped
+], UsesForall);
+export { UsesForall };
+let UsesNot = class UsesNot extends ScopedVisitor {
+    constructor(scope) {
+        super(scope);
+    }
+    visitNot(node) {
+        throw new StopTraversalException();
+    }
+    visitExist(node) {
+        if (node.identifier.value === "not")
+            throw new StopTraversalException();
+    }
+};
+UsesNot = __decorate([
+    AutoScoped
+], UsesNot);
+export { UsesNot };
+export const logicInspections = {
+    DeclaresFact: DeclaresFact,
+    DeclaresRule: DeclaresRule,
+    DeclaresPredicate: DeclaresPredicate,
+    UsesFindall: UsesFindall,
+    HasFindall: UsesFindall,
+    UsesForall: UsesForall,
+    HasForall: UsesForall,
+    UsesNot: UsesNot,
+    HasNot: UsesNot,
+};