yukigo 0.2.3 → 0.3.2

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

@@ -1,349 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,109 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,58 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

@@ -1,96 +0,0 @@
-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,
-};