yukigo 0.2.3 → 0.3.2

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

@@ -7,7 +7,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 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;
+    return node.is(Sequence) && node.statements.length === 0;
 }
 /**
  * Basic Levenshtein distance for typo detection
@@ -32,9 +32,8 @@ function getLevenshteinDistance(a, b) {
 }
 let DiscardsExceptions = class DiscardsExceptions extends ScopedVisitor {
     visitCatch(node) {
-        if (!node.body ||
-            node.body instanceof NilPrimitive ||
-            isSequenceEmpty(node.body)) {
+        const doesNotCatch = !node.body || node.body.is(NilPrimitive) || isSequenceEmpty(node.body);
+        if (doesNotCatch) {
             throw new StopTraversalException();
         }
     }
@@ -54,7 +53,7 @@ let DoesConsolePrint = class DoesConsolePrint extends ScopedVisitor {
     }
     visitApplication(node) {
         const func = node.functionExpr;
-        if (!(func instanceof SymbolPrimitive))
+        if (!func.is(SymbolPrimitive))
             return func.accept(this);
         const name = func.value;
         if (this.isPrintFunc(name))
@@ -85,22 +84,18 @@ let HasDeclarationTypos = class HasDeclarationTypos extends ScopedVisitor {
      * (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();
-                    }
-                }
-            }
-        }
+        const names = node.statements
+            .filter((stmt) => stmt.is(Variable))
+            .map((stmt) => stmt.identifier.value);
+        names.forEach((nameA, i) => {
+            const hasTypo = names.slice(i + 1).some((nameB) => {
+                if (nameA.length <= 3 || nameB.length <= 3)
+                    return false;
+                return getLevenshteinDistance(nameA, nameB) <= 2;
+            });
+            if (hasTypo)
+                throw new StopTraversalException();
+        });
     }
 };
 HasDeclarationTypos = __decorate([
@@ -110,7 +105,7 @@ export { HasDeclarationTypos };
 let HasEmptyIfBranches = class HasEmptyIfBranches extends ScopedVisitor {
     visitIf(node) {
         const isThenEmpty = !node.then || isSequenceEmpty(node.then);
-        const isElseEmpty = node.elseExpr && isSequenceEmpty(node.elseExpr);
+        const isElseEmpty = isSequenceEmpty(node.elseExpr);
         if (isThenEmpty || isElseEmpty)
             throw new StopTraversalException();
     }
@@ -166,8 +161,8 @@ HasMisspelledIdentifiers = __decorate([
 export { HasMisspelledIdentifiers };
 let HasRedundantBooleanComparison = class HasRedundantBooleanComparison extends ScopedVisitor {
     visitLogicalBinaryOperation(node) {
-        const isLeftBool = node.left instanceof BooleanPrimitive;
-        const isRightBool = node.right instanceof BooleanPrimitive;
+        const isLeftBool = node.left.is(BooleanPrimitive);
+        const isRightBool = node.right.is(BooleanPrimitive);
         if (isLeftBool || isRightBool)
             throw new StopTraversalException();
     }
@@ -178,17 +173,14 @@ HasRedundantBooleanComparison = __decorate([
 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();
-                }
-            }
-        }
+        if (!node.elseExpr)
+            return;
+        const { then, elseExpr } = node;
+        if (this.isBooleanBlock(then) && this.isBooleanBlock(elseExpr))
+            throw new StopTraversalException();
+    }
+    isBooleanBlock(node) {
+        return (node.is(Sequence) && node.statements.some((s) => s.is(BooleanPrimitive)));
     }
 };
 HasRedundantIf = __decorate([
@@ -203,16 +195,21 @@ let HasRedundantLocalVariableReturn = class HasRedundantLocalVariableReturn exte
      */
     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();
-                }
+        stmts.forEach((stmt, i) => {
+            const next = stmts[i + 1];
+            if (!next)
+                return;
+            if (this.isPointlessAssignment(stmt, next)) {
+                throw new StopTraversalException();
             }
-        }
+        });
+    }
+    isPointlessAssignment(current, next) {
+        return (current.is(Variable) &&
+            next.is(Return) &&
+            next.body !== undefined &&
+            next.body.is(SymbolPrimitive) &&
+            next.body.value === current.identifier.value);
     }
 };
 HasRedundantLocalVariableReturn = __decorate([
@@ -240,26 +237,20 @@ HasTooShortIdentifiers = __decorate([
 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();
-                    }
-                }
-            }
-        }
+        const { statements } = node;
+        const declared = new Set(statements
+            .filter((stmt) => stmt.is(Function) || stmt.is(Variable))
+            .map((stmt) => stmt.identifier.value));
+        const called = statements
+            .filter((stmt) => stmt.is(Call))
+            .map((stmt) => stmt.callee.value);
+        const hasTypo = called.some((usage) => {
+            if (declared.has(usage) || usage.length <= 3)
+                return false;
+            return Array.from(declared).some((decl) => getLevenshteinDistance(usage, decl) <= 1);
+        });
+        if (hasTypo)
+            throw new StopTraversalException();
     }
 };
 HasUsageTypos = __decorate([

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

@@ -1,6 +1,6 @@
-import { Enumeration, ForLoop, Procedure, Repeat, Switch, TraverseVisitor, While } from "yukigo-ast";
-import { ScopedVisitor, VisitorConstructor } from "../../utils.js";
-export declare class DeclaresEnumeration extends TraverseVisitor {
+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;

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

@@ -4,9 +4,9 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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, TraverseVisitor, } from "yukigo-ast";
-import { AutoScoped, ScopedVisitor } from "../../utils.js";
-export class DeclaresEnumeration extends TraverseVisitor {
+import { StopTraversalException, } from "yukigo-ast";
+import { AutoScoped, ScopedVisitor, InspectionVisitor, } from "../../utils.js";
+export class DeclaresEnumeration extends InspectionVisitor {
     enumName;
     constructor(enumName) {
         super();

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

@@ -3,6 +3,7 @@ import { ScopedVisitor, VisitorConstructor } from "../../utils.js";
 export declare class HasAssignmentCondition extends ScopedVisitor {
     visitIf(node: If): void;
     visitWhile(node: While): void;
+    private isConditionAssignment;
 }
 export declare class HasAssignmentReturn extends ScopedVisitor {
     visitReturn(node: Return): void;

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

@@ -8,13 +8,16 @@ import { Assignment, NumberPrimitive, Sequence, StopTraversalException, } from "
 import { AutoScoped, ScopedVisitor } from "../../utils.js";
 let HasAssignmentCondition = class HasAssignmentCondition extends ScopedVisitor {
     visitIf(node) {
-        if (node.condition instanceof Assignment)
+        if (this.isConditionAssignment(node.condition))
             throw new StopTraversalException();
     }
     visitWhile(node) {
-        if (node.condition instanceof Assignment)
+        if (this.isConditionAssignment(node.condition))
             throw new StopTraversalException();
     }
+    isConditionAssignment(node) {
+        return node.is(Assignment);
+    }
 };
 HasAssignmentCondition = __decorate([
     AutoScoped
@@ -22,7 +25,7 @@ HasAssignmentCondition = __decorate([
 export { HasAssignmentCondition };
 let HasAssignmentReturn = class HasAssignmentReturn extends ScopedVisitor {
     visitReturn(node) {
-        if (node.body && node.body instanceof Assignment)
+        if (node.body && node.body.is(Assignment))
             throw new StopTraversalException();
     }
 };
@@ -32,7 +35,7 @@ HasAssignmentReturn = __decorate([
 export { HasAssignmentReturn };
 let HasEmptyRepeat = class HasEmptyRepeat extends ScopedVisitor {
     visitRepeat(node) {
-        if (node.body instanceof Sequence && node.body.statements.length === 0)
+        if (node.body.is(Sequence) && node.body.statements.length === 0)
             throw new StopTraversalException();
     }
 };
@@ -42,7 +45,7 @@ HasEmptyRepeat = __decorate([
 export { HasEmptyRepeat };
 let HasRedundantRepeat = class HasRedundantRepeat extends ScopedVisitor {
     visitRepeat(node) {
-        if (node.count instanceof NumberPrimitive && node.count.value === 1)
+        if (node.count.is(NumberPrimitive) && node.count.value === 1)
             throw new StopTraversalException();
     }
 };

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

@@ -1,18 +1,18 @@
-import { Exist, Fact, Findall, Forall, Not, Rule, TraverseVisitor } from "yukigo-ast";
-import { ScopedVisitor, VisitorConstructor } from "../../utils.js";
-export declare class DeclaresFact extends TraverseVisitor {
+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);
+    constructor(target?: string | undefined);
     visitFact(node: Fact): void;
 }
-export declare class DeclaresRule extends TraverseVisitor {
+export declare class DeclaresRule extends InspectionVisitor {
     private readonly target?;
-    constructor(target?: string);
+    constructor(target?: string | undefined);
     visitRule(node: Rule): void;
 }
-export declare class DeclaresPredicate extends TraverseVisitor {
+export declare class DeclaresPredicate extends InspectionVisitor {
     private readonly target?;
-    constructor(target?: string);
+    constructor(target?: string | undefined);
     visitFact(node: Fact): void;
     visitRule(node: Rule): void;
 }

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

@@ -4,9 +4,9 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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, TraverseVisitor, } from "yukigo-ast";
-import { AutoScoped, ScopedVisitor } from "../../utils.js";
-export class DeclaresFact extends TraverseVisitor {
+import { StopTraversalException, } from "yukigo-ast";
+import { AutoScoped, ScopedVisitor, InspectionVisitor } from "../../utils.js";
+export class DeclaresFact extends InspectionVisitor {
     target;
     constructor(target) {
         super();
@@ -18,7 +18,7 @@ export class DeclaresFact extends TraverseVisitor {
             throw new StopTraversalException();
     }
 }
-export class DeclaresRule extends TraverseVisitor {
+export class DeclaresRule extends InspectionVisitor {
     target;
     constructor(target) {
         super();
@@ -30,7 +30,7 @@ export class DeclaresRule extends TraverseVisitor {
             throw new StopTraversalException();
     }
 }
-export class DeclaresPredicate extends TraverseVisitor {
+export class DeclaresPredicate extends InspectionVisitor {
     target;
     constructor(target) {
         super();

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

@@ -10,10 +10,10 @@ let HasRedundantReduction = class HasRedundantReduction extends ScopedVisitor {
     visitAssignOperation(node) {
         const left = node.left;
         const right = node.right;
-        if (!(left instanceof SymbolPrimitive))
+        if (!left.is(SymbolPrimitive))
             return;
         const redundantReductionParameters = isYukigoPrimitive(right);
-        const redundantReductionFunctors = right instanceof Exist;
+        const redundantReductionFunctors = right.is(Exist);
         const isRedundant = redundantReductionParameters || redundantReductionFunctors;
         if (isRedundant)
             throw new StopTraversalException();

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

@@ -1,5 +1,5 @@
-import { Attribute, Class, Interface, Method, New, Object, PrimitiveMethod, Send, TraverseVisitor } from "yukigo-ast";
-import { ScopedVisitor, VisitorConstructor } from "../../utils.js";
+import { 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);
@@ -10,7 +10,7 @@ export declare class DeclaresClass extends ScopedVisitor {
     constructor(className: string, scope?: string);
     visitClass(node: Class): void;
 }
-export declare class DeclaresInterface extends TraverseVisitor {
+export declare class DeclaresInterface extends InspectionVisitor {
     private interfaceName;
     constructor(interfaceName: string);
     visitInterface(node: Interface): void;
@@ -20,7 +20,7 @@ export declare class DeclaresMethod extends ScopedVisitor {
     constructor(methodName: string, scope?: string);
     visitMethod(node: Method): void;
 }
-export declare class DeclaresObject extends TraverseVisitor {
+export declare class DeclaresObject extends InspectionVisitor {
     private objectName;
     constructor(objectName: string);
     visitObject(node: Object): void;
@@ -69,7 +69,7 @@ export declare class UsesObjectComposition extends ScopedVisitor {
     constructor(scope?: string);
     visitAttribute(node: Attribute): void;
 }
-export declare class UsesStaticMethodOverload extends TraverseVisitor {
+export declare class UsesStaticMethodOverload extends InspectionVisitor {
     private scopes;
     visitClass(node: Class): void;
     visitObject(node: Object): void;

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

@@ -4,8 +4,8 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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, TraverseVisitor, } from "yukigo-ast";
-import { AutoScoped, ScopedVisitor } from "../../utils.js";
+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) {
@@ -36,7 +36,7 @@ DeclaresClass = __decorate([
     AutoScoped
 ], DeclaresClass);
 export { DeclaresClass };
-export class DeclaresInterface extends TraverseVisitor {
+export class DeclaresInterface extends InspectionVisitor {
     interfaceName;
     constructor(interfaceName) {
         super();
@@ -62,7 +62,7 @@ DeclaresMethod = __decorate([
     AutoScoped
 ], DeclaresMethod);
 export { DeclaresMethod };
-export class DeclaresObject extends TraverseVisitor {
+export class DeclaresObject extends InspectionVisitor {
     objectName;
     constructor(objectName) {
         super();
@@ -110,8 +110,9 @@ let Implements = class Implements extends ScopedVisitor {
         this.interfaceName = interfaceName;
     }
     visitClass(node) {
-        if (node.implementsNode &&
-            node.implementsNode.identifier.value === this.interfaceName)
+        const { implementsNode } = node;
+        if (implementsNode &&
+            implementsNode.identifier.value === this.interfaceName)
             throw new StopTraversalException();
     }
 };
@@ -203,7 +204,7 @@ let UsesObjectComposition = class UsesObjectComposition extends ScopedVisitor {
         super(scope);
     }
     visitAttribute(node) {
-        if (node.expression instanceof New)
+        if (node.expression.is(New))
             throw new StopTraversalException();
     }
 };
@@ -211,7 +212,7 @@ UsesObjectComposition = __decorate([
     AutoScoped
 ], UsesObjectComposition);
 export { UsesObjectComposition };
-export class UsesStaticMethodOverload extends TraverseVisitor {
+export class UsesStaticMethodOverload extends InspectionVisitor {
     scopes = [];
     visitClass(node) {
         this.scopes.push(new Set());
@@ -250,7 +251,7 @@ let AbstractMethodCollector = class AbstractMethodCollector extends ScopedVisito
         super(scope);
     }
     visitMethod(node) {
-        if (node.getMetadata("isAbstract") === true)
+        if (node.isAbstract)
             this.abstractMethods.add(node.identifier.value);
     }
     // stop propagation to not mix scopes
@@ -278,18 +279,18 @@ let UsesTemplateMethod = class UsesTemplateMethod extends ScopedVisitor {
         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();
-        }
+        if (!node.receiver.is(Self))
+            return;
+        if (this.abstractMethodsStack.length === 0)
+            return;
+        const currentAbstractMethods = this.abstractMethodsStack[0];
+        // This doesnt match if message is complex expression
+        if (!node.selector.is(SymbolPrimitive))
+            return;
+        const selectorName = node.selector.value;
+        const isMessageAbstract = currentAbstractMethods.has(selectorName);
+        if (isMessageAbstract)
+            throw new StopTraversalException();
     }
 };
 UsesTemplateMethod = __decorate([

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

@@ -4,10 +4,10 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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, TraverseVisitor, } from "yukigo-ast";
-import { AutoScoped, ScopedVisitor } from "../../utils.js";
+import { NilPrimitive, StopTraversalException, StringPrimitive, } from "yukigo-ast";
+import { AutoScoped, InspectionVisitor, ScopedVisitor, } from "../../utils.js";
 import { Uses } from "../generic/generic.js";
-class MethodCollector extends TraverseVisitor {
+class MethodCollector extends InspectionVisitor {
     collectedMethods = [];
     collect(node) {
         node.expression.accept(this);
@@ -19,10 +19,8 @@ class MethodCollector extends TraverseVisitor {
 }
 let DoesNilTest = class DoesNilTest extends ScopedVisitor {
     visitLogicalBinaryOperation(node) {
-        if (node.left instanceof NilPrimitive ||
-            node.right instanceof NilPrimitive) {
+        if (node.left.is(NilPrimitive) || node.right.is(NilPrimitive))
             throw new StopTraversalException();
-        }
     }
 };
 DoesNilTest = __decorate([
@@ -31,8 +29,7 @@ DoesNilTest = __decorate([
 export { DoesNilTest };
 let DoesTypeTest = class DoesTypeTest extends ScopedVisitor {
     visitLogicalBinaryOperation(node) {
-        if (node.left instanceof StringPrimitive ||
-            node.right instanceof StringPrimitive) {
+        if (node.left.is(StringPrimitive) || node.right.is(StringPrimitive)) {
             throw new StopTraversalException();
         }
     }
@@ -43,7 +40,7 @@ DoesTypeTest = __decorate([
 export { DoesTypeTest };
 let ReturnsNil = class ReturnsNil extends ScopedVisitor {
     visitReturn(node) {
-        if (!Boolean(node.body) || node.body instanceof NilPrimitive)
+        if (!node.body || node.body.is(NilPrimitive))
             throw new StopTraversalException();
     }
 };
@@ -52,7 +49,7 @@ ReturnsNil = __decorate([
 ], ReturnsNil);
 export { ReturnsNil };
 let HasTooManyMethods = class HasTooManyMethods extends ScopedVisitor {
-    counter;
+    counter = 0;
     maxMethods;
     constructor(maxMethods = 10, scopeName) {
         super(scopeName);
@@ -90,11 +87,9 @@ let OverridesEqualOrHashButNotBoth = class OverridesEqualOrHashButNotBoth extend
         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))
+        const hasEquals = names.some((n) => ["equals", "==", "eql?"].includes(n));
+        const hasHash = names.some((n) => ["hashCode", "hash"].includes(n));
+        if (hasEquals !== hasHash)
             throw new StopTraversalException();
     }
 };
@@ -111,14 +106,7 @@ let UsesNamedSelfReference = class UsesNamedSelfReference extends ScopedVisitor
     }
     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;
-        }
+        body.accept(checker);
     }
 };
 UsesNamedSelfReference = __decorate([

package/dist/analyzer/utils.d.ts

@@ -1,4 +1,7 @@
-import { Class, Fact, Function, Method, Object as YuObject, Procedure, Rule, TraverseVisitor, Variable } from "yukigo-ast";
+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;
@@ -6,7 +9,7 @@ export interface VisitorConstructor {
     IS_INTRANSITIVE?: boolean;
 }
 export type InspectionMap = Record<string, VisitorConstructor>;
-export declare class ScopedVisitor extends TraverseVisitor {
+export declare class ScopedVisitor extends InspectionVisitor {
     protected binding?: string;
     inScope: boolean;
     constructor(binding?: string);
@@ -19,6 +22,7 @@ export declare class ScopedVisitor extends TraverseVisitor {
     visitRule(node: Rule): void;
     visitFact(node: Fact): void;
     visitProcedure(node: Procedure): void;
+    fallback(node: ASTNode): void;
     private manageScope;
 }
 export declare function AutoScoped<T extends {

package/dist/analyzer/utils.js

@@ -1,7 +1,10 @@
 import { TraverseVisitor, } from "yukigo-ast";
-export class ScopedVisitor extends TraverseVisitor {
+export class InspectionVisitor extends TraverseVisitor {
+    fallback(node) { }
+}
+export class ScopedVisitor extends InspectionVisitor {
     binding;
-    inScope;
+    inScope = false;
     constructor(binding) {
         super();
         this.setBinding(binding);
@@ -34,6 +37,7 @@ export class ScopedVisitor extends TraverseVisitor {
     visitProcedure(node) {
         this.manageScope(node, () => super.visitProcedure(node));
     }
+    fallback(node) { }
     manageScope(node, traverse) {
         const isTarget = node.identifier.value === this.binding;
         if (isTarget)

package/dist/interpreter/components/EnvBuilder.d.ts

@@ -1,5 +1,6 @@
-import { AST, ASTNode, Class, Fact, Function, Rule, TraverseVisitor, Object, Variable, Sequence } from "yukigo-ast";
+import { AST, ASTNode, Attribute, Class, Fact, Function, Method, Rule, TraverseVisitor, Object, Variable, Sequence } from "yukigo-ast";
 import { RuntimeContext } from "./RuntimeContext.js";
+import { RuntimeFunction, YuValue } from "../primitives/index.js";
 /**
  * Builds the initial environment by collecting all top-level function declarations.
  * Each function captures a closure of the environment at its definition time,
@@ -7,14 +8,32 @@ import { RuntimeContext } from "./RuntimeContext.js";
  */
 export declare class EnvBuilderVisitor extends TraverseVisitor {
     private ctx;
+    private deferredInitializations;
     constructor(ctx: RuntimeContext);
     build(ast: AST): void;
+    private declareGlobalSymbols;
+    private initializeGlobalStates;
     visitSequence(node: Sequence): void;
     visitFunction(node: Function): void;
     visitClass(node: Class): void;
     visitObject(node: Object): void;
+    private resolveObjectFields;
+    private collectAllInitializers;
     visitFact(node: Fact): void;
     visitRule(node: Rule): void;
+    private getClassFields;
+    private getClassInitializers;
     visitVariable(node: Variable): void;
     visit(node: ASTNode): void;
+    fallback(node: ASTNode): string;
+}
+export declare class OOPCollector extends TraverseVisitor {
+    private ctx;
+    collectedMethods: Map<string, RuntimeFunction>;
+    collectedFields: Map<string, YuValue>;
+    fieldInitializers: Map<string, ASTNode>;
+    constructor(ctx: RuntimeContext);
+    visitMethod(node: Method): void;
+    visitAttribute(node: Attribute): void;
+    fallback(node: ASTNode): string;
 }