yukigo 0.2.0 → 0.2.3

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

@@ -0,0 +1,15 @@
+import { AssignOperation, Exist, UnifyOperation } from "yukigo-ast";
+import { ScopedVisitor, VisitorConstructor } from "../../utils.js";
+export declare class HasRedundantReduction extends ScopedVisitor {
+    visitAssignOperation(node: AssignOperation): void;
+}
+export declare class UsesUnificationOperator extends ScopedVisitor {
+    visitUnifyOperation(node: UnifyOperation): void;
+}
+export declare class UsesCut extends ScopedVisitor {
+    visitExist(node: Exist): void;
+}
+export declare class UsesFail extends ScopedVisitor {
+    visitExist(node: Exist): void;
+}
+export declare const logicSmells: Record<string, VisitorConstructor>;

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

@@ -0,0 +1,60 @@
+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 { Exist, isYukigoPrimitive, StopTraversalException, SymbolPrimitive, } from "yukigo-ast";
+import { AutoScoped, ScopedVisitor } from "../../utils.js";
+let HasRedundantReduction = class HasRedundantReduction extends ScopedVisitor {
+    visitAssignOperation(node) {
+        const left = node.left;
+        const right = node.right;
+        if (!(left instanceof SymbolPrimitive))
+            return;
+        const redundantReductionParameters = isYukigoPrimitive(right);
+        const redundantReductionFunctors = right instanceof Exist;
+        const isRedundant = redundantReductionParameters || redundantReductionFunctors;
+        if (isRedundant)
+            throw new StopTraversalException();
+    }
+};
+HasRedundantReduction = __decorate([
+    AutoScoped
+], HasRedundantReduction);
+export { HasRedundantReduction };
+let UsesUnificationOperator = class UsesUnificationOperator extends ScopedVisitor {
+    visitUnifyOperation(node) {
+        throw new StopTraversalException();
+    }
+};
+UsesUnificationOperator = __decorate([
+    AutoScoped
+], UsesUnificationOperator);
+export { UsesUnificationOperator };
+let UsesCut = class UsesCut extends ScopedVisitor {
+    visitExist(node) {
+        if (node.identifier.value === "!")
+            throw new StopTraversalException();
+    }
+};
+UsesCut = __decorate([
+    AutoScoped
+], UsesCut);
+export { UsesCut };
+let UsesFail = class UsesFail extends ScopedVisitor {
+    visitExist(node) {
+        if (node.identifier.value === "fail")
+            throw new StopTraversalException();
+    }
+};
+UsesFail = __decorate([
+    AutoScoped
+], UsesFail);
+export { UsesFail };
+export const logicSmells = {
+    HasRedundantReduction: HasRedundantReduction,
+    UsesCut: UsesCut,
+    UsesFail: UsesFail,
+    UsesUnificationOperator: UsesUnificationOperator,
+};

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

@@ -0,0 +1,90 @@
+import { ASTNode, Attribute, Class, Interface, Method, New, Object, PrimitiveMethod, Send } from "yukigo-ast";
+import { InspectionVisitor, ScopedVisitor, VisitorConstructor } from "../../utils.js";
+export declare class DeclaresAttribute extends ScopedVisitor {
+    private attributeName;
+    constructor(attributeName: string, scope?: string);
+    visitAttribute(node: Attribute): void;
+}
+export declare class DeclaresClass extends ScopedVisitor {
+    private className;
+    constructor(className: string, scope?: string);
+    visitClass(node: Class): void;
+}
+export declare class DeclaresInterface extends InspectionVisitor {
+    private interfaceName;
+    constructor(interfaceName: string);
+    visitInterface(node: Interface): void;
+    fallback(node: ASTNode): void;
+}
+export declare class DeclaresMethod extends ScopedVisitor {
+    private methodName;
+    constructor(methodName: string, scope?: string);
+    visitMethod(node: Method): void;
+}
+export declare class DeclaresObject extends InspectionVisitor {
+    private objectName;
+    constructor(objectName: string);
+    visitObject(node: Object): void;
+    fallback(node: ASTNode): void;
+}
+export declare class DeclaresPrimitive extends ScopedVisitor {
+    private operatorName;
+    constructor(operatorName: string, scope?: string);
+    visitPrimitiveMethod(node: PrimitiveMethod): void;
+}
+export declare class DeclaresSuperclass extends ScopedVisitor {
+    private superclassName;
+    constructor(superclassName: string, scope?: string);
+    visitClass(node: Class): void;
+}
+export declare class Implements extends ScopedVisitor {
+    private interfaceName;
+    constructor(interfaceName: string, scope?: string);
+    visitClass(node: Class): void;
+}
+export declare class IncludeMixin extends ScopedVisitor {
+    private mixinsName;
+    constructor(mixinsName: string, scope?: string);
+    visitClass(node: Class): void;
+}
+export declare class Instantiates extends ScopedVisitor {
+    private className;
+    constructor(className: string, scope?: string);
+    visitNew(node: New): void;
+}
+export declare class UsesDynamicPolymorphism extends ScopedVisitor {
+    private selectorName;
+    private count;
+    constructor(selectorName: string, scope?: string);
+    visitMethod(node: Method): void;
+}
+export declare class UsesInheritance extends ScopedVisitor {
+    constructor(scope?: string);
+    visitClass(node: Class): void;
+    visitInterface(node: Interface): void;
+}
+export declare class UsesMixins extends ScopedVisitor {
+    constructor(scope?: string);
+    visitClass(node: Class): void;
+}
+export declare class UsesObjectComposition extends ScopedVisitor {
+    constructor(scope?: string);
+    visitAttribute(node: Attribute): void;
+}
+export declare class UsesStaticMethodOverload extends InspectionVisitor {
+    private scopes;
+    visitClass(node: Class): void;
+    visitObject(node: Object): void;
+    visitMethod(node: Method): void;
+}
+export declare class UsesDynamicMethodOverload extends ScopedVisitor {
+    constructor(scope?: string);
+    visitMethod(node: Method): void;
+}
+export declare class UsesTemplateMethod extends ScopedVisitor {
+    private abstractMethodsStack;
+    constructor(scope?: string);
+    visitClass(node: Class): void;
+    visitSend(node: Send): void;
+}
+export declare const objectInspections: Record<string, VisitorConstructor>;

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

@@ -0,0 +1,321 @@
+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 { New, Self, StopTraversalException, SymbolPrimitive, } from "yukigo-ast";
+import { AutoScoped, InspectionVisitor, ScopedVisitor } from "../../utils.js";
+let DeclaresAttribute = class DeclaresAttribute extends ScopedVisitor {
+    attributeName;
+    constructor(attributeName, scope) {
+        super(scope);
+        this.attributeName = attributeName;
+    }
+    visitAttribute(node) {
+        if (node.identifier.value === this.attributeName)
+            throw new StopTraversalException();
+    }
+};
+DeclaresAttribute = __decorate([
+    AutoScoped
+], DeclaresAttribute);
+export { DeclaresAttribute };
+let DeclaresClass = class DeclaresClass extends ScopedVisitor {
+    className;
+    constructor(className, scope) {
+        super(scope);
+        this.className = className;
+    }
+    visitClass(node) {
+        if (node.identifier.value === this.className)
+            throw new StopTraversalException();
+    }
+};
+DeclaresClass = __decorate([
+    AutoScoped
+], DeclaresClass);
+export { DeclaresClass };
+export class DeclaresInterface extends InspectionVisitor {
+    interfaceName;
+    constructor(interfaceName) {
+        super();
+        this.interfaceName = interfaceName;
+    }
+    visitInterface(node) {
+        if (node.identifier.value === this.interfaceName)
+            throw new StopTraversalException();
+    }
+    fallback(node) { }
+}
+let DeclaresMethod = class DeclaresMethod extends ScopedVisitor {
+    methodName;
+    constructor(methodName, scope) {
+        super(scope);
+        this.methodName = methodName;
+    }
+    visitMethod(node) {
+        if (node.identifier.value === this.methodName)
+            throw new StopTraversalException();
+    }
+};
+DeclaresMethod = __decorate([
+    AutoScoped
+], DeclaresMethod);
+export { DeclaresMethod };
+export class DeclaresObject extends InspectionVisitor {
+    objectName;
+    constructor(objectName) {
+        super();
+        this.objectName = objectName;
+    }
+    visitObject(node) {
+        if (node.identifier.value === this.objectName)
+            throw new StopTraversalException();
+    }
+    fallback(node) { }
+}
+let DeclaresPrimitive = class DeclaresPrimitive extends ScopedVisitor {
+    operatorName;
+    constructor(operatorName, scope) {
+        super(scope);
+        this.operatorName = operatorName;
+    }
+    visitPrimitiveMethod(node) {
+        if (node.operator === this.operatorName)
+            throw new StopTraversalException();
+    }
+};
+DeclaresPrimitive = __decorate([
+    AutoScoped
+], DeclaresPrimitive);
+export { DeclaresPrimitive };
+let DeclaresSuperclass = class DeclaresSuperclass extends ScopedVisitor {
+    superclassName;
+    constructor(superclassName, scope) {
+        super(scope);
+        this.superclassName = superclassName;
+    }
+    visitClass(node) {
+        if (node.extendsSymbol && node.extendsSymbol.value === this.superclassName)
+            throw new StopTraversalException();
+    }
+};
+DeclaresSuperclass = __decorate([
+    AutoScoped
+], DeclaresSuperclass);
+export { DeclaresSuperclass };
+let Implements = class Implements extends ScopedVisitor {
+    interfaceName;
+    constructor(interfaceName, scope) {
+        super(scope);
+        this.interfaceName = interfaceName;
+    }
+    visitClass(node) {
+        if (node.implementsNode &&
+            node.implementsNode.identifier.value === this.interfaceName)
+            throw new StopTraversalException();
+    }
+};
+Implements = __decorate([
+    AutoScoped
+], Implements);
+export { Implements };
+let IncludeMixin = class IncludeMixin extends ScopedVisitor {
+    mixinsName;
+    constructor(mixinsName, scope) {
+        super(scope);
+        this.mixinsName = mixinsName;
+    }
+    visitClass(node) {
+        if (node.includes.some((sym) => sym.value === this.mixinsName))
+            throw new StopTraversalException();
+    }
+};
+IncludeMixin = __decorate([
+    AutoScoped
+], IncludeMixin);
+export { IncludeMixin };
+let Instantiates = class Instantiates extends ScopedVisitor {
+    className;
+    constructor(className, scope) {
+        super(scope);
+        this.className = className;
+    }
+    visitNew(node) {
+        if (node.identifier.value === this.className)
+            throw new StopTraversalException();
+    }
+};
+Instantiates = __decorate([
+    AutoScoped
+], Instantiates);
+export { Instantiates };
+let UsesDynamicPolymorphism = class UsesDynamicPolymorphism extends ScopedVisitor {
+    selectorName;
+    count = 0;
+    constructor(selectorName, scope) {
+        super(scope);
+        this.selectorName = selectorName;
+    }
+    visitMethod(node) {
+        if (node.identifier.value === this.selectorName) {
+            this.count++;
+            if (this.count >= 2)
+                throw new StopTraversalException();
+        }
+    }
+};
+UsesDynamicPolymorphism = __decorate([
+    AutoScoped
+], UsesDynamicPolymorphism);
+export { UsesDynamicPolymorphism };
+let UsesInheritance = class UsesInheritance extends ScopedVisitor {
+    constructor(scope) {
+        super(scope);
+    }
+    visitClass(node) {
+        if (node.extendsSymbol)
+            throw new StopTraversalException();
+    }
+    visitInterface(node) {
+        if (node.extendsSymbol && node.extendsSymbol.length > 0)
+            throw new StopTraversalException();
+    }
+};
+UsesInheritance = __decorate([
+    AutoScoped
+], UsesInheritance);
+export { UsesInheritance };
+let UsesMixins = class UsesMixins extends ScopedVisitor {
+    constructor(scope) {
+        super(scope);
+    }
+    visitClass(node) {
+        if (node.includes.length > 0)
+            throw new StopTraversalException();
+    }
+};
+UsesMixins = __decorate([
+    AutoScoped
+], UsesMixins);
+export { UsesMixins };
+let UsesObjectComposition = class UsesObjectComposition extends ScopedVisitor {
+    constructor(scope) {
+        super(scope);
+    }
+    visitAttribute(node) {
+        if (node.expression instanceof New)
+            throw new StopTraversalException();
+    }
+};
+UsesObjectComposition = __decorate([
+    AutoScoped
+], UsesObjectComposition);
+export { UsesObjectComposition };
+export class UsesStaticMethodOverload extends InspectionVisitor {
+    scopes = [];
+    visitClass(node) {
+        this.scopes.push(new Set());
+        node.expression.accept(this);
+        this.scopes.pop();
+    }
+    visitObject(node) {
+        this.scopes.push(new Set());
+        node.expression.accept(this);
+        this.scopes.pop();
+    }
+    visitMethod(node) {
+        const currentScope = this.scopes[0];
+        const methodName = node.identifier.value;
+        if (currentScope.has(methodName))
+            throw new StopTraversalException();
+        currentScope.add(methodName);
+    }
+}
+let UsesDynamicMethodOverload = class UsesDynamicMethodOverload extends ScopedVisitor {
+    constructor(scope) {
+        super(scope);
+    }
+    visitMethod(node) {
+        if (node.equations.length > 1)
+            throw new StopTraversalException();
+    }
+};
+UsesDynamicMethodOverload = __decorate([
+    AutoScoped
+], UsesDynamicMethodOverload);
+export { UsesDynamicMethodOverload };
+let AbstractMethodCollector = class AbstractMethodCollector extends ScopedVisitor {
+    abstractMethods = new Set();
+    constructor(scope) {
+        super(scope);
+    }
+    visitMethod(node) {
+        if (node.getMetadata("isAbstract") === true)
+            this.abstractMethods.add(node.identifier.value);
+    }
+    // stop propagation to not mix scopes
+    visitClass(node) {
+        return;
+    }
+    visitObject(node) {
+        return;
+    }
+};
+AbstractMethodCollector = __decorate([
+    AutoScoped
+], AbstractMethodCollector);
+let UsesTemplateMethod = class UsesTemplateMethod extends ScopedVisitor {
+    abstractMethodsStack = [];
+    constructor(scope) {
+        super(scope);
+    }
+    visitClass(node) {
+        const collector = new AbstractMethodCollector(this.binding);
+        if (node.expression)
+            node.expression.accept(collector);
+        this.abstractMethodsStack.push(collector.abstractMethods);
+        node.expression.accept(this);
+        this.abstractMethodsStack.pop();
+    }
+    visitSend(node) {
+        if (node.receiver instanceof Self) {
+            if (this.abstractMethodsStack.length === 0)
+                return;
+            const currentAbstractMethods = this.abstractMethodsStack[0];
+            // This doesnt match if message is complex expression
+            if (!(node.selector instanceof SymbolPrimitive))
+                return;
+            const selectorName = node.selector.value;
+            const isMessageAbstract = currentAbstractMethods.has(selectorName);
+            if (isMessageAbstract)
+                throw new StopTraversalException();
+        }
+    }
+};
+UsesTemplateMethod = __decorate([
+    AutoScoped
+], UsesTemplateMethod);
+export { UsesTemplateMethod };
+export const objectInspections = {
+    DeclaresAttribute: DeclaresAttribute,
+    DeclaresClass: DeclaresClass,
+    DeclaresInterface: DeclaresInterface,
+    DeclaresMethod: DeclaresMethod,
+    DeclaresObject: DeclaresObject,
+    DeclaresPrimitive: DeclaresPrimitive,
+    DeclaresSuperclass: DeclaresSuperclass,
+    Implements: Implements,
+    IncludeMixin: IncludeMixin,
+    Inherits: DeclaresSuperclass, // alias for DeclaresSuperclass
+    Instantiates: Instantiates,
+    UsesDynamicPolymorphism: UsesDynamicPolymorphism,
+    UsesInheritance: UsesInheritance,
+    UsesMixins: UsesMixins,
+    UsesObjectComposition: UsesObjectComposition,
+    UsesStaticMethodOverload: UsesStaticMethodOverload,
+    UsesDynamicMethodOverload: UsesDynamicMethodOverload,
+    UsesTemplateMethod: UsesTemplateMethod,
+    UsesStaticPolymorphism: UsesStaticMethodOverload, // alias for UsesStaticMethodOverload
+};

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

@@ -0,0 +1,30 @@
+import { Class, Interface, LogicalBinaryOperation, Method, Object, Return } from "yukigo-ast";
+import { ScopedVisitor, VisitorConstructor } from "../../utils.js";
+export declare class DoesNilTest extends ScopedVisitor {
+    visitLogicalBinaryOperation(node: LogicalBinaryOperation): void;
+}
+export declare class DoesTypeTest extends ScopedVisitor {
+    visitLogicalBinaryOperation(node: LogicalBinaryOperation): void;
+}
+export declare class ReturnsNil extends ScopedVisitor {
+    visitReturn(node: Return): void;
+}
+export declare class HasTooManyMethods extends ScopedVisitor {
+    private counter;
+    private readonly maxMethods;
+    constructor(maxMethods?: number, scopeName?: string);
+    visitInterface(node: Interface): void;
+    visitClass(node: Class): void;
+    visitObject(node: Object): void;
+    visitMethod(node: Method): void;
+    private checkMethodCount;
+}
+export declare class OverridesEqualOrHashButNotBoth extends ScopedVisitor {
+    visitClass(node: Class): void;
+}
+export declare class UsesNamedSelfReference extends ScopedVisitor {
+    visitObject(node: Object): void;
+    visitClass(node: Class): void;
+    private checkSelfReference;
+}
+export declare const objectSmells: Record<string, VisitorConstructor>;

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

@@ -0,0 +1,135 @@
+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 { NilPrimitive, StopTraversalException, StringPrimitive, } from "yukigo-ast";
+import { AutoScoped, InspectionVisitor, ScopedVisitor } from "../../utils.js";
+import { Uses } from "../generic/generic.js";
+class MethodCollector extends InspectionVisitor {
+    collectedMethods = [];
+    collect(node) {
+        node.expression.accept(this);
+        return this.collectedMethods;
+    }
+    visitMethod(node) {
+        this.collectedMethods.push(node);
+    }
+}
+let DoesNilTest = class DoesNilTest extends ScopedVisitor {
+    visitLogicalBinaryOperation(node) {
+        if (node.left instanceof NilPrimitive ||
+            node.right instanceof NilPrimitive) {
+            throw new StopTraversalException();
+        }
+    }
+};
+DoesNilTest = __decorate([
+    AutoScoped
+], DoesNilTest);
+export { DoesNilTest };
+let DoesTypeTest = class DoesTypeTest extends ScopedVisitor {
+    visitLogicalBinaryOperation(node) {
+        if (node.left instanceof StringPrimitive ||
+            node.right instanceof StringPrimitive) {
+            throw new StopTraversalException();
+        }
+    }
+};
+DoesTypeTest = __decorate([
+    AutoScoped
+], DoesTypeTest);
+export { DoesTypeTest };
+let ReturnsNil = class ReturnsNil extends ScopedVisitor {
+    visitReturn(node) {
+        if (!Boolean(node.body) || node.body instanceof NilPrimitive)
+            throw new StopTraversalException();
+    }
+};
+ReturnsNil = __decorate([
+    AutoScoped
+], ReturnsNil);
+export { ReturnsNil };
+let HasTooManyMethods = class HasTooManyMethods extends ScopedVisitor {
+    counter = 0;
+    maxMethods;
+    constructor(maxMethods = 10, scopeName) {
+        super(scopeName);
+        this.maxMethods = maxMethods;
+    }
+    visitInterface(node) {
+        node.expression.accept(this);
+        this.checkMethodCount();
+        this.counter = 0;
+    }
+    visitClass(node) {
+        node.expression.accept(this);
+        this.checkMethodCount();
+        this.counter = 0;
+    }
+    visitObject(node) {
+        node.expression.accept(this);
+        this.checkMethodCount();
+        this.counter = 0;
+    }
+    visitMethod(node) {
+        this.counter += 1;
+    }
+    checkMethodCount() {
+        if (this.counter > this.maxMethods)
+            throw new StopTraversalException();
+    }
+};
+HasTooManyMethods = __decorate([
+    AutoScoped
+], HasTooManyMethods);
+export { HasTooManyMethods };
+let OverridesEqualOrHashButNotBoth = class OverridesEqualOrHashButNotBoth extends ScopedVisitor {
+    visitClass(node) {
+        const collector = new MethodCollector();
+        const methods = collector.collect(node);
+        const names = methods.map((m) => m.identifier.value);
+        const hasEquals = names.includes("equals") ||
+            names.includes("==") ||
+            names.includes("eql?");
+        const hasHash = names.includes("hashCode") || names.includes("hash");
+        if ((hasEquals && !hasHash) || (!hasEquals && hasHash))
+            throw new StopTraversalException();
+    }
+};
+OverridesEqualOrHashButNotBoth = __decorate([
+    AutoScoped
+], OverridesEqualOrHashButNotBoth);
+export { OverridesEqualOrHashButNotBoth };
+let UsesNamedSelfReference = class UsesNamedSelfReference extends ScopedVisitor {
+    visitObject(node) {
+        this.checkSelfReference(node.identifier.value, node.expression);
+    }
+    visitClass(node) {
+        this.checkSelfReference(node.identifier.value, node.expression);
+    }
+    checkSelfReference(selfName, body) {
+        const checker = new Uses(selfName, this.binding);
+        try {
+            body.accept(checker);
+        }
+        catch (e) {
+            if (e instanceof StopTraversalException)
+                throw new StopTraversalException();
+            throw e;
+        }
+    }
+};
+UsesNamedSelfReference = __decorate([
+    AutoScoped
+], UsesNamedSelfReference);
+export { UsesNamedSelfReference };
+export const objectSmells = {
+    DoesNilTest: DoesNilTest,
+    DoesTypeTest: DoesTypeTest,
+    HasTooManyMethods: HasTooManyMethods,
+    OverridesEqualOrHashButNotBoth: OverridesEqualOrHashButNotBoth,
+    ReturnsNil: ReturnsNil,
+    UsesNamedSelfReference: UsesNamedSelfReference,
+};

package/dist/src/analyzer/utils.d.ts

@@ -0,0 +1,30 @@
+import { Class, Fact, Function, Method, Object as YuObject, Procedure, Rule, TraverseVisitor, Variable, ASTNode } from "yukigo-ast";
+export declare class InspectionVisitor extends TraverseVisitor {
+    fallback(node: ASTNode): void;
+}
+export interface VisitorConstructor {
+    new (...args: any[]): TraverseVisitor & {
+        setBinding?(binding: string): void;
+    };
+    IS_INTRANSITIVE?: boolean;
+}
+export type InspectionMap = Record<string, VisitorConstructor>;
+export declare class ScopedVisitor extends InspectionVisitor {
+    protected binding?: string;
+    inScope: boolean;
+    constructor(binding?: string);
+    setBinding(binding?: string): void;
+    visitVariable(node: Variable): void;
+    visitFunction(node: Function): void;
+    visitClass(node: Class): void;
+    visitObject(node: YuObject): void;
+    visitMethod(node: Method): void;
+    visitRule(node: Rule): void;
+    visitFact(node: Fact): void;
+    visitProcedure(node: Procedure): void;
+    fallback(node: ASTNode): void;
+    private manageScope;
+}
+export declare function AutoScoped<T extends {
+    new (...args: any[]): any;
+}>(constructor: T): void;