yukigo 0.2.2 → 0.3.1

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

@@ -1,14 +1,14 @@
-import { Lambda, Equation, GuardedBody } from "yukigo-ast";
+import { Lambda, Equation, Guard } from "yukigo-ast";
 import { ScopedVisitor, VisitorConstructor } from "../../utils.js";
 export declare class HasRedundantLambda extends ScopedVisitor {
     visitLambda(node: Lambda): void;
 }
 export declare class HasRedundantGuards extends ScopedVisitor {
-    visitEquation(node: Equation): void;
+    visitGuard(node: Guard): void;
     private isAlwaysTrue;
 }
 export declare class ShouldUseOtherwise extends ScopedVisitor {
-    visitGuardedBody(node: GuardedBody): void;
+    visitGuard(node: Guard): void;
 }
 export declare class HasRedundantParameter extends ScopedVisitor {
     visitEquation(node: Equation): void;

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

@@ -4,24 +4,24 @@ 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 { Call, VariablePattern, Variable, StopTraversalException, BooleanPrimitive, Application, isUnguardedBody, Otherwise, } from "yukigo-ast";
+import { Call, VariablePattern, Variable, StopTraversalException, BooleanPrimitive, Application, Otherwise, } from "yukigo-ast";
 import { AutoScoped, ScopedVisitor } from "../../utils.js";
 import { Uses } from "../generic/generic.js";
 let HasRedundantLambda = class HasRedundantLambda extends ScopedVisitor {
     visitLambda(node) {
         if (node.parameters.length !== 1)
             return;
-        if (!(node.body instanceof Application))
+        if (!node.body.is(Application))
             return;
         const param = node.parameters[0];
         const call = node.body;
-        if (call.functionExpr instanceof Application ||
-            call.functionExpr instanceof Call)
+        if (call.functionExpr.is(Application) || call.functionExpr.is(Call))
             return;
         const arg = call.parameter;
-        if (param instanceof VariablePattern &&
-            arg instanceof Variable &&
-            param.name.value === arg.identifier.value)
+        const hasRedudantParam = param.is(VariablePattern) &&
+            arg.is(Variable) &&
+            param.name.value === arg.identifier.value;
+        if (hasRedudantParam)
             throw new StopTraversalException();
     }
 };
@@ -30,23 +30,16 @@ HasRedundantLambda = __decorate([
 ], HasRedundantLambda);
 export { HasRedundantLambda };
 let HasRedundantGuards = class HasRedundantGuards extends ScopedVisitor {
-    visitEquation(node) {
-        if (isUnguardedBody(node.body))
-            return;
-        // If there is only 1 guard...
-        if (node.body.length === 1) {
-            const guard = node.body[0];
-            // ...and that guard is "True" or "otherwise"
-            if (this.isAlwaysTrue(guard.condition))
-                throw new StopTraversalException();
-        }
+    visitGuard(node) {
+        if (this.isAlwaysTrue(node.condition))
+            throw new StopTraversalException();
     }
     isAlwaysTrue(node) {
         // check for boolean literal 'True'
-        if (node instanceof BooleanPrimitive && node.value === true)
+        if (node.is(BooleanPrimitive) && node.value === true)
             return true;
         // check for default case
-        if (node instanceof Otherwise)
+        if (node.is(Otherwise))
             return true;
         return false;
     }
@@ -56,9 +49,8 @@ HasRedundantGuards = __decorate([
 ], HasRedundantGuards);
 export { HasRedundantGuards };
 let ShouldUseOtherwise = class ShouldUseOtherwise extends ScopedVisitor {
-    visitGuardedBody(node) {
-        if (node.condition instanceof BooleanPrimitive &&
-            node.condition.value === true)
+    visitGuard(node) {
+        if (node.condition.is(BooleanPrimitive) && node.condition.value === true)
             throw new StopTraversalException();
     }
 };
@@ -69,19 +61,19 @@ export { ShouldUseOtherwise };
 let HasRedundantParameter = class HasRedundantParameter extends ScopedVisitor {
     visitEquation(node) {
         for (const pattern of node.patterns) {
-            if (pattern instanceof VariablePattern) {
-                const paramName = pattern.name.value;
-                const usageChecker = new Uses(paramName, this.binding);
-                try {
-                    node.accept(usageChecker);
-                    // uses didnt throw so the param is not being used
-                    throw new StopTraversalException();
-                }
-                catch (e) {
-                    if (e instanceof StopTraversalException)
-                        continue;
-                    throw e;
-                }
+            if (!pattern.is(VariablePattern))
+                continue;
+            const paramName = pattern.name.value;
+            const usageChecker = new Uses(paramName, this.binding);
+            try {
+                node.accept(usageChecker);
+                // uses didnt throw so the param is not being used
+                throw new StopTraversalException();
+            }
+            catch (e) {
+                if (e instanceof StopTraversalException)
+                    continue;
+                throw e;
             }
         }
     }

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

@@ -1,5 +1,5 @@
-import { ArithmeticBinaryOperation, ArithmeticUnaryOperation, Assignment, ASTNode, Attribute, Call, Catch, Class, EntryPoint, Equation, Fact, Function, If, LogicalBinaryOperation, LogicalUnaryOperation, Method, Object, Print, Procedure, Raise, Record as RecordNode, Rule, SimpleType, SymbolPrimitive, TraverseVisitor, Try, TypeAlias, TypeSignature, TypeVar, Variable } from "yukigo-ast";
-import { VisitorConstructor, ScopedVisitor } from "../../utils.js";
+import { ArithmeticBinaryOperation, ArithmeticUnaryOperation, Assignment, Attribute, Call, Catch, Class, EntryPoint, Equation, Fact, Function, If, LogicalBinaryOperation, LogicalUnaryOperation, Method, Object, Print, Procedure, Raise, Record as RecordNode, Rule, SimpleType, SymbolPrimitive, Try, TypeAlias, TypeSignature, TypeVar, Variable } from "yukigo-ast";
+import { VisitorConstructor, ScopedVisitor, InspectionVisitor } from "../../utils.js";
 export declare class Assigns extends ScopedVisitor {
     private readonly targetIdentifier;
     constructor(targetIdentifier: string, scope?: string);
@@ -44,7 +44,7 @@ export declare class DeclaresComputationWithArity extends ScopedVisitor {
     visitFact(node: Fact): void;
     visitRule(node: Rule): void;
 }
-export declare class DeclaresEntryPoint extends TraverseVisitor {
+export declare class DeclaresEntryPoint extends InspectionVisitor {
     visitEntryPoint(node: EntryPoint): void;
 }
 export declare class DeclaresFunction extends ScopedVisitor {
@@ -52,6 +52,7 @@ export declare class DeclaresFunction extends ScopedVisitor {
     constructor(targetBinding: string, scope?: string);
     visitFunction(node: Function): void;
 }
+type CallableDeclaration = Function | Method | Procedure | Fact | Rule;
 export declare class DeclaresRecursively extends ScopedVisitor {
     private readonly targetBinding;
     constructor(targetBinding: string, scope?: string);
@@ -60,9 +61,9 @@ export declare class DeclaresRecursively extends ScopedVisitor {
     visitProcedure(node: Procedure): void;
     visitFact(node: Fact): void;
     visitRule(node: Rule): void;
-    visitNested(node: ASTNode): void;
+    visitNested(node: CallableDeclaration): void;
 }
-export declare class HasDirectRecursion extends TraverseVisitor {
+export declare class HasDirectRecursion extends InspectionVisitor {
     private readonly binding;
     private isInsideBody;
     constructor(binding: string);
@@ -73,12 +74,12 @@ export declare class HasDirectRecursion extends TraverseVisitor {
     visitEquation(node: Equation): void;
     visitSymbolPrimitive(node: SymbolPrimitive): void;
 }
-export declare class DeclaresTypeAlias extends TraverseVisitor {
+export declare class DeclaresTypeAlias extends InspectionVisitor {
     private readonly typeAliasName;
     constructor(typeAliasName: string);
     visitTypeAlias(node: TypeAlias): void;
 }
-export declare class DeclaresTypeSignature extends TraverseVisitor {
+export declare class DeclaresTypeSignature extends InspectionVisitor {
     private readonly targetBinding;
     constructor(targetBinding: string);
     visitTypeSignature(node: TypeSignature): void;
@@ -121,41 +122,46 @@ export declare class UsesType extends ScopedVisitor {
     visitSimpleType(node: SimpleType): void;
     visitTypeVar(node: TypeVar): void;
 }
-export declare class HasBinding extends ScopedVisitor {
+export declare class HasBinding extends InspectionVisitor {
+    private readonly targetBinding;
+    constructor(targetBinding: string);
+    private check;
     visitFunction(node: Function): void;
     visitObject(node: Object): void;
     visitClass(node: Class): void;
     visitRule(node: Rule): void;
     visitFact(node: Fact): void;
     visitTypeAlias(node: TypeAlias): void;
-    visitTypeSignature(node: TypeSignature): void;
     visitRecord(node: RecordNode): void;
+    visitVariable(node: Variable): void;
+    visitMethod(node: Method): void;
+    visitProcedure(node: Procedure): void;
 }
-export declare class SubordinatesDeclarationsTo extends TraverseVisitor {
+export declare class SubordinatesDeclarationsTo extends InspectionVisitor {
     private childName;
     private parentName;
     constructor(childName: string, parentName: string);
     visitFunction(node: Function): void;
 }
-export declare class SubordinatesDeclarationsToEntryPoint extends TraverseVisitor {
+export declare class SubordinatesDeclarationsToEntryPoint extends InspectionVisitor {
     private childName;
     constructor(childName: string);
     visitEntryPoint(node: EntryPoint): void;
 }
-export declare class TypesAs extends TraverseVisitor {
+export declare class TypesAs extends InspectionVisitor {
     private typeName;
     private bindingName;
     constructor(typeName: string, bindingName: string);
     visitTypeSignature(node: TypeSignature): void;
 }
-export declare class TypesParameterAs extends TraverseVisitor {
+export declare class TypesParameterAs extends InspectionVisitor {
     private paramIndex;
     private typeName;
     private bindingName;
     constructor(paramIndex: number, typeName: string, bindingName: string);
     visitTypeSignature(node: TypeSignature): void;
 }
-export declare class TypesReturnAs extends TraverseVisitor {
+export declare class TypesReturnAs extends InspectionVisitor {
     private typeName;
     private bindingName;
     constructor(typeName: string, bindingName: string);
@@ -176,3 +182,4 @@ export declare class UsesExceptions extends ScopedVisitor {
     visitRaise(node: Raise): void;
 }
 export declare const genericInspections: Record<string, VisitorConstructor>;
+export {};

package/dist/analyzer/inspections/generic/generic.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 { isUnguardedBody, ParameterizedType, StopTraversalException, SymbolPrimitive, TraverseVisitor, VariablePattern, } from "yukigo-ast";
-import { ScopedVisitor, AutoScoped } from "../../utils.js";
+import { NativeBody, ParameterizedType, StopTraversalException, SymbolPrimitive, VariablePattern, } from "yukigo-ast";
+import { ScopedVisitor, InspectionVisitor, AutoScoped, } from "../../utils.js";
 let Assigns = class Assigns extends ScopedVisitor {
     targetIdentifier;
     constructor(targetIdentifier, scope) {
@@ -158,7 +158,7 @@ DeclaresComputationWithArity = __decorate([
     AutoScoped
 ], DeclaresComputationWithArity);
 export { DeclaresComputationWithArity };
-export class DeclaresEntryPoint extends TraverseVisitor {
+export class DeclaresEntryPoint extends InspectionVisitor {
     visitEntryPoint(node) {
         throw new StopTraversalException();
     }
@@ -182,7 +182,7 @@ let DeclaresRecursively = class DeclaresRecursively extends ScopedVisitor {
     targetBinding;
     constructor(targetBinding, scope) {
         super(scope);
-        this.targetBinding = targetBinding;
+        this.targetBinding = new SymbolPrimitive(targetBinding);
     }
     visitFunction(node) {
         super.visitFunction(node);
@@ -205,9 +205,8 @@ let DeclaresRecursively = class DeclaresRecursively extends ScopedVisitor {
         this.visitNested(node);
     }
     visitNested(node) {
-        if ("identifier" in node &&
-            node.identifier instanceof SymbolPrimitive &&
-            node.identifier.value === this.targetBinding)
+        const hasOwnIdentifier = node.identifier.equals(this.targetBinding);
+        if (hasOwnIdentifier)
             throw new StopTraversalException();
     }
 };
@@ -215,7 +214,7 @@ DeclaresRecursively = __decorate([
     AutoScoped
 ], DeclaresRecursively);
 export { DeclaresRecursively };
-export class HasDirectRecursion extends TraverseVisitor {
+export class HasDirectRecursion extends InspectionVisitor {
     binding;
     isInsideBody = false;
     constructor(binding) {
@@ -245,12 +244,9 @@ export class HasDirectRecursion extends TraverseVisitor {
     visitEquation(node) {
         this.isInsideBody = true;
         try {
-            if (isUnguardedBody(node.body)) {
-                node.body.accept(this);
-            }
-            else {
-                this.traverseCollection(node.body);
-            }
+            if (node.body instanceof NativeBody)
+                return;
+            node.body.accept(this);
         }
         finally {
             this.isInsideBody = false;
@@ -261,7 +257,7 @@ export class HasDirectRecursion extends TraverseVisitor {
             throw new StopTraversalException();
     }
 }
-export class DeclaresTypeAlias extends TraverseVisitor {
+export class DeclaresTypeAlias extends InspectionVisitor {
     typeAliasName;
     constructor(typeAliasName) {
         super();
@@ -272,7 +268,7 @@ export class DeclaresTypeAlias extends TraverseVisitor {
             throw new StopTraversalException();
     }
 }
-export class DeclaresTypeSignature extends TraverseVisitor {
+export class DeclaresTypeSignature extends InspectionVisitor {
     targetBinding;
     constructor(targetBinding) {
         super();
@@ -398,37 +394,59 @@ UsesType = __decorate([
     AutoScoped
 ], UsesType);
 export { UsesType };
-let HasBinding = class HasBinding extends ScopedVisitor {
+export class HasBinding extends InspectionVisitor {
+    targetBinding;
+    constructor(targetBinding) {
+        super();
+        this.targetBinding = targetBinding;
+    }
+    check(identifier) {
+        if (identifier && identifier.value === this.targetBinding) {
+            throw new StopTraversalException();
+        }
+    }
     visitFunction(node) {
-        throw new StopTraversalException();
+        this.check(node.identifier);
+        super.visitFunction(node);
     }
     visitObject(node) {
-        throw new StopTraversalException();
+        this.check(node.identifier);
+        super.visitObject(node);
     }
     visitClass(node) {
-        throw new StopTraversalException();
+        this.check(node.identifier);
+        super.visitClass(node);
     }
     visitRule(node) {
-        throw new StopTraversalException();
+        this.check(node.identifier);
+        super.visitRule(node);
     }
     visitFact(node) {
-        throw new StopTraversalException();
+        this.check(node.identifier);
+        super.visitFact(node);
     }
     visitTypeAlias(node) {
-        throw new StopTraversalException();
-    }
-    visitTypeSignature(node) {
-        throw new StopTraversalException();
+        this.check(node.identifier);
+        super.visitTypeAlias(node);
     }
     visitRecord(node) {
-        throw new StopTraversalException();
+        this.check(node.name);
+        super.visitRecord(node);
     }
-};
-HasBinding = __decorate([
-    AutoScoped
-], HasBinding);
-export { HasBinding };
-export class SubordinatesDeclarationsTo extends TraverseVisitor {
+    visitVariable(node) {
+        this.check(node.identifier);
+        super.visitVariable(node);
+    }
+    visitMethod(node) {
+        this.check(node.identifier);
+        super.visitMethod(node);
+    }
+    visitProcedure(node) {
+        this.check(node.identifier);
+        super.visitProcedure(node);
+    }
+}
+export class SubordinatesDeclarationsTo extends InspectionVisitor {
     childName;
     parentName;
     constructor(childName, parentName) {
@@ -446,7 +464,7 @@ export class SubordinatesDeclarationsTo extends TraverseVisitor {
         }
     }
 }
-export class SubordinatesDeclarationsToEntryPoint extends TraverseVisitor {
+export class SubordinatesDeclarationsToEntryPoint extends InspectionVisitor {
     childName;
     constructor(childName) {
         super();
@@ -457,7 +475,7 @@ export class SubordinatesDeclarationsToEntryPoint extends TraverseVisitor {
         node.expression.statements.forEach((stmt) => stmt.accept(childFinder));
     }
 }
-export class TypesAs extends TraverseVisitor {
+export class TypesAs extends InspectionVisitor {
     typeName;
     bindingName;
     constructor(typeName, bindingName) {
@@ -475,7 +493,11 @@ export class TypesAs extends TraverseVisitor {
         }
     }
 }
-export class TypesParameterAs extends TraverseVisitor {
+function isFormatAgnosticMatch(actual, expected) {
+    const normalize = (str) => str.replace(/\s+/g, " ").trim();
+    return normalize(actual) === normalize(expected);
+}
+export class TypesParameterAs extends InspectionVisitor {
     paramIndex;
     typeName;
     bindingName;
@@ -486,21 +508,19 @@ export class TypesParameterAs extends TraverseVisitor {
         this.bindingName = bindingName;
     }
     visitTypeSignature(node) {
-        if (node.identifier.value === this.bindingName) {
-            if (node.body instanceof ParameterizedType) {
-                const paramType = node.body.inputs[this.paramIndex];
-                if (paramType) {
-                    const actualType = paramType.toString();
-                    if (actualType.replace(/\s+/g, " ").trim() ===
-                        this.typeName.replace(/\s+/g, " ").trim()) {
-                        throw new StopTraversalException();
-                    }
-                }
-            }
-        }
+        if (node.identifier.value !== this.bindingName)
+            return;
+        if (!node.body.is(ParameterizedType))
+            return;
+        const paramType = node.body.inputs[this.paramIndex];
+        if (!paramType)
+            return;
+        const actualType = paramType.toString();
+        if (isFormatAgnosticMatch(actualType, this.typeName))
+            throw new StopTraversalException();
     }
 }
-export class TypesReturnAs extends TraverseVisitor {
+export class TypesReturnAs extends InspectionVisitor {
     typeName;
     bindingName;
     constructor(typeName, bindingName) {
@@ -509,14 +529,12 @@ export class TypesReturnAs extends TraverseVisitor {
         this.bindingName = bindingName;
     }
     visitTypeSignature(node) {
-        if (node.identifier.value === this.bindingName) {
-            if (node.body instanceof ParameterizedType) {
-                const actualType = node.body.returnType.toString();
-                if (actualType.replace(/\s+/g, " ").trim() ===
-                    this.typeName.replace(/\s+/g, " ").trim()) {
-                    throw new StopTraversalException();
-                }
-            }
+        if (node.identifier.value !== this.bindingName)
+            return;
+        if (node.body.is(ParameterizedType)) {
+            const actualType = node.body.returnType.toString();
+            if (isFormatAgnosticMatch(actualType, this.typeName))
+                throw new StopTraversalException();
         }
     }
 }
@@ -528,8 +546,9 @@ let Rescues = class Rescues extends ScopedVisitor {
     }
     visitCatch(node) {
         for (const pattern of node.patterns) {
-            if (pattern instanceof VariablePattern &&
-                pattern.name.value === this.exceptionName) {
+            const capturesExceptionAs = pattern.is(VariablePattern) &&
+                pattern.name.value === this.exceptionName;
+            if (capturesExceptionAs) {
                 throw new StopTraversalException();
             }
         }

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

@@ -32,9 +32,11 @@ export declare class HasRedundantBooleanComparison extends ScopedVisitor {
 }
 export declare class HasRedundantIf extends ScopedVisitor {
     visitIf(node: If): void;
+    private isBooleanBlock;
 }
 export declare class HasRedundantLocalVariableReturn extends ScopedVisitor {
     visitSequence(node: Sequence): void;
+    private isPointlessAssignment;
 }
 export declare class HasTooShortIdentifiers extends ScopedVisitor {
     private readonly minLength;