yukigo 0.2.0 → 0.2.3

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

@@ -0,0 +1,604 @@
+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 { isUnguardedBody, ParameterizedType, StopTraversalException, SymbolPrimitive, VariablePattern, } from "yukigo-ast";
+import { ScopedVisitor, InspectionVisitor, AutoScoped, } from "../../utils.js";
+let Assigns = class Assigns extends ScopedVisitor {
+    targetIdentifier;
+    constructor(targetIdentifier, scope) {
+        super(scope);
+        this.targetIdentifier = targetIdentifier;
+    }
+    visitVariable(node) {
+        if (node.identifier.value === this.targetIdentifier)
+            throw new StopTraversalException();
+    }
+    visitAttribute(node) {
+        if (node.identifier.value === this.targetIdentifier)
+            throw new StopTraversalException();
+    }
+    visitAssignment(node) {
+        if (node.identifier.value === this.targetIdentifier)
+            throw new StopTraversalException();
+    }
+};
+Assigns = __decorate([
+    AutoScoped
+], Assigns);
+export { Assigns };
+let Calls = class Calls extends ScopedVisitor {
+    targetCallee;
+    constructor(targetCallee, scope) {
+        super(scope);
+        this.targetCallee = targetCallee;
+    }
+    visitCall(node) {
+        if (node.callee.value === this.targetCallee)
+            throw new StopTraversalException();
+    }
+};
+Calls = __decorate([
+    AutoScoped
+], Calls);
+export { Calls };
+let Declares = class Declares extends ScopedVisitor {
+    targetIdentifier;
+    constructor(targetIdentifier, scopeName) {
+        super(scopeName);
+        this.targetIdentifier = targetIdentifier;
+    }
+    check(node) {
+        if (node.identifier.value === this.targetIdentifier)
+            throw new StopTraversalException();
+    }
+    visitFunction(node) {
+        if (this.inScope)
+            this.check(node);
+        super.visitFunction(node);
+    }
+    visitMethod(node) {
+        if (this.inScope)
+            this.check(node);
+        super.visitMethod(node);
+    }
+    visitProcedure(node) {
+        if (this.inScope)
+            this.check(node);
+        super.visitProcedure(node);
+    }
+    visitRule(node) {
+        if (this.inScope)
+            this.check(node);
+        super.visitRule(node);
+    }
+    visitFact(node) {
+        if (this.inScope)
+            this.check(node);
+        super.visitFact(node);
+    }
+    visitVariable(node) {
+        this.check(node);
+    }
+    visitAttribute(node) {
+        this.check(node);
+    }
+    visitTypeAlias(node) {
+        this.check(node);
+    }
+    visitTypeSignature(node) {
+        this.check(node);
+    }
+};
+Declares = __decorate([
+    AutoScoped
+], Declares);
+export { Declares };
+let DeclaresComputation = class DeclaresComputation extends ScopedVisitor {
+    callName;
+    constructor(callName, scope) {
+        super(scope);
+        this.callName = callName;
+    }
+    visitFunction(node) {
+        if (node.identifier.value === this.callName)
+            throw new StopTraversalException();
+    }
+    visitMethod(node) {
+        if (node.identifier.value === this.callName)
+            throw new StopTraversalException();
+    }
+    visitProcedure(node) {
+        if (node.identifier.value === this.callName)
+            throw new StopTraversalException();
+    }
+    visitFact(node) {
+        if (node.identifier.value === this.callName)
+            throw new StopTraversalException();
+    }
+    visitRule(node) {
+        if (node.identifier.value === this.callName)
+            throw new StopTraversalException();
+    }
+};
+DeclaresComputation = __decorate([
+    AutoScoped
+], DeclaresComputation);
+export { DeclaresComputation };
+let DeclaresComputationWithArity = class DeclaresComputationWithArity extends ScopedVisitor {
+    targetArity;
+    constructor(targetArity, scope) {
+        super(scope);
+        this.targetArity = Number(targetArity);
+    }
+    visitFunction(node) {
+        if (node.equations.some((eq) => eq.patterns.length === this.targetArity))
+            throw new StopTraversalException();
+    }
+    visitMethod(node) {
+        if (node.equations.some((eq) => eq.patterns.length === this.targetArity))
+            throw new StopTraversalException();
+    }
+    visitProcedure(node) {
+        if (node.equations.some((eq) => eq.patterns.length === this.targetArity))
+            throw new StopTraversalException();
+    }
+    visitFact(node) {
+        if (node.patterns.length === this.targetArity)
+            throw new StopTraversalException();
+    }
+    visitRule(node) {
+        if (node.equations.some((eq) => eq.patterns.length === this.targetArity))
+            throw new StopTraversalException();
+    }
+};
+DeclaresComputationWithArity = __decorate([
+    AutoScoped
+], DeclaresComputationWithArity);
+export { DeclaresComputationWithArity };
+export class DeclaresEntryPoint extends InspectionVisitor {
+    visitEntryPoint(node) {
+        throw new StopTraversalException();
+    }
+}
+let DeclaresFunction = class DeclaresFunction extends ScopedVisitor {
+    targetBinding;
+    constructor(targetBinding, scope) {
+        super(scope);
+        this.targetBinding = targetBinding;
+    }
+    visitFunction(node) {
+        if (node.identifier.value === this.targetBinding)
+            throw new StopTraversalException();
+    }
+};
+DeclaresFunction = __decorate([
+    AutoScoped
+], DeclaresFunction);
+export { DeclaresFunction };
+let DeclaresRecursively = class DeclaresRecursively extends ScopedVisitor {
+    targetBinding;
+    constructor(targetBinding, scope) {
+        super(scope);
+        this.targetBinding = targetBinding;
+    }
+    visitFunction(node) {
+        super.visitFunction(node);
+        this.visitNested(node);
+    }
+    visitMethod(node) {
+        super.visitMethod(node);
+        this.visitNested(node);
+    }
+    visitProcedure(node) {
+        super.visitProcedure(node);
+        this.visitNested(node);
+    }
+    visitFact(node) {
+        super.visitFact(node);
+        this.visitNested(node);
+    }
+    visitRule(node) {
+        super.visitRule(node);
+        this.visitNested(node);
+    }
+    visitNested(node) {
+        if ("identifier" in node &&
+            node.identifier instanceof SymbolPrimitive &&
+            node.identifier.value === this.targetBinding)
+            throw new StopTraversalException();
+    }
+};
+DeclaresRecursively = __decorate([
+    AutoScoped
+], DeclaresRecursively);
+export { DeclaresRecursively };
+export class HasDirectRecursion extends InspectionVisitor {
+    binding;
+    isInsideBody = false;
+    constructor(binding) {
+        super();
+        this.binding = binding;
+    }
+    visitFunction(node) {
+        if (node.identifier.value !== this.binding)
+            return;
+        this.traverseCollection(node.equations);
+    }
+    visitRule(node) {
+        if (node.identifier.value !== this.binding)
+            return;
+        this.traverseCollection(node.equations);
+    }
+    visitProcedure(node) {
+        if (node.identifier.value !== this.binding)
+            return;
+        this.traverseCollection(node.equations);
+    }
+    visitMethod(node) {
+        if (node.identifier.value !== this.binding)
+            return;
+        this.traverseCollection(node.equations);
+    }
+    visitEquation(node) {
+        this.isInsideBody = true;
+        try {
+            if (isUnguardedBody(node.body)) {
+                node.body.accept(this);
+            }
+            else {
+                this.traverseCollection(node.body);
+            }
+        }
+        finally {
+            this.isInsideBody = false;
+        }
+    }
+    visitSymbolPrimitive(node) {
+        if (this.isInsideBody && node.value === this.binding)
+            throw new StopTraversalException();
+    }
+}
+export class DeclaresTypeAlias extends InspectionVisitor {
+    typeAliasName;
+    constructor(typeAliasName) {
+        super();
+        this.typeAliasName = typeAliasName;
+    }
+    visitTypeAlias(node) {
+        if (node.identifier.value === this.typeAliasName)
+            throw new StopTraversalException();
+    }
+}
+export class DeclaresTypeSignature extends InspectionVisitor {
+    targetBinding;
+    constructor(targetBinding) {
+        super();
+        this.targetBinding = targetBinding;
+    }
+    visitTypeSignature(node) {
+        if (node.identifier.value === this.targetBinding)
+            throw new StopTraversalException();
+    }
+}
+let DeclaresVariable = class DeclaresVariable extends ScopedVisitor {
+    targetBinding;
+    constructor(targetBinding, scope) {
+        super(scope);
+        this.targetBinding = targetBinding;
+    }
+    visitVariable(node) {
+        if (node.identifier.value === this.targetBinding)
+            throw new StopTraversalException();
+    }
+};
+DeclaresVariable = __decorate([
+    AutoScoped
+], DeclaresVariable);
+export { DeclaresVariable };
+let Raises = class Raises extends ScopedVisitor {
+    constructor(scope) {
+        super(scope);
+    }
+    visitRaise(node) {
+        throw new StopTraversalException();
+    }
+};
+Raises = __decorate([
+    AutoScoped
+], Raises);
+export { Raises };
+let Uses = class Uses extends ScopedVisitor {
+    targetBinding;
+    constructor(targetBinding, scope) {
+        super(scope);
+        this.targetBinding = targetBinding;
+    }
+    visitSymbolPrimitive(node) {
+        if (node.value === this.targetBinding)
+            throw new StopTraversalException();
+    }
+};
+Uses = __decorate([
+    AutoScoped
+], Uses);
+export { Uses };
+let UsesArithmetic = class UsesArithmetic extends ScopedVisitor {
+    constructor(scope) {
+        super(scope);
+    }
+    visitArithmeticBinaryOperation(node) {
+        throw new StopTraversalException();
+    }
+    visitArithmeticUnaryOperation(node) {
+        throw new StopTraversalException();
+    }
+};
+UsesArithmetic = __decorate([
+    AutoScoped
+], UsesArithmetic);
+export { UsesArithmetic };
+let UsesConditional = class UsesConditional extends ScopedVisitor {
+    visitIf(node) {
+        throw new StopTraversalException();
+    }
+};
+UsesConditional = __decorate([
+    AutoScoped
+], UsesConditional);
+export { UsesConditional };
+let UsesLogic = class UsesLogic extends ScopedVisitor {
+    constructor(scope) {
+        super(scope);
+    }
+    visitLogicalBinaryOperation(node) {
+        throw new StopTraversalException();
+    }
+    visitLogicalUnaryOperation(node) {
+        throw new StopTraversalException();
+    }
+};
+UsesLogic = __decorate([
+    AutoScoped
+], UsesLogic);
+export { UsesLogic };
+let UsesPrint = class UsesPrint extends ScopedVisitor {
+    constructor(scope) {
+        super(scope);
+    }
+    visitPrint(node) {
+        throw new StopTraversalException();
+    }
+};
+UsesPrint = __decorate([
+    AutoScoped
+], UsesPrint);
+export { UsesPrint };
+let UsesType = class UsesType extends ScopedVisitor {
+    targetBinding;
+    constructor(targetBinding, scope) {
+        super(scope);
+        this.targetBinding = targetBinding;
+    }
+    visitTypeSignature(node) {
+        node.body.accept(this);
+    }
+    visitSimpleType(node) {
+        if (node.value === this.targetBinding)
+            throw new StopTraversalException();
+    }
+    visitTypeVar(node) {
+        if (node.value === this.targetBinding)
+            throw new StopTraversalException();
+    }
+};
+UsesType = __decorate([
+    AutoScoped
+], UsesType);
+export { UsesType };
+let HasBinding = class HasBinding extends ScopedVisitor {
+    visitFunction(node) {
+        throw new StopTraversalException();
+    }
+    visitObject(node) {
+        throw new StopTraversalException();
+    }
+    visitClass(node) {
+        throw new StopTraversalException();
+    }
+    visitRule(node) {
+        throw new StopTraversalException();
+    }
+    visitFact(node) {
+        throw new StopTraversalException();
+    }
+    visitTypeAlias(node) {
+        throw new StopTraversalException();
+    }
+    visitTypeSignature(node) {
+        throw new StopTraversalException();
+    }
+    visitRecord(node) {
+        throw new StopTraversalException();
+    }
+};
+HasBinding = __decorate([
+    AutoScoped
+], HasBinding);
+export { HasBinding };
+export class SubordinatesDeclarationsTo extends InspectionVisitor {
+    childName;
+    parentName;
+    constructor(childName, parentName) {
+        super();
+        this.childName = childName;
+        this.parentName = parentName;
+    }
+    visitFunction(node) {
+        if (node.identifier.value === this.parentName) {
+            const childFinder = new Declares(this.childName);
+            node.equations.forEach((eq) => eq.accept(childFinder)); // we expect that this will throw if find the subordinated decl
+        }
+        else {
+            super.visitFunction(node);
+        }
+    }
+}
+export class SubordinatesDeclarationsToEntryPoint extends InspectionVisitor {
+    childName;
+    constructor(childName) {
+        super();
+        this.childName = childName;
+    }
+    visitEntryPoint(node) {
+        const childFinder = new Declares(this.childName);
+        node.expression.statements.forEach((stmt) => stmt.accept(childFinder));
+    }
+}
+export class TypesAs extends InspectionVisitor {
+    typeName;
+    bindingName;
+    constructor(typeName, bindingName) {
+        super();
+        this.typeName = typeName;
+        this.bindingName = bindingName;
+    }
+    visitTypeSignature(node) {
+        if (node.identifier.value === this.bindingName) {
+            const actualType = node.body.toString();
+            if (actualType.replace(/\s+/g, " ").trim() ===
+                this.typeName.replace(/\s+/g, " ").trim()) {
+                throw new StopTraversalException();
+            }
+        }
+    }
+}
+export class TypesParameterAs extends InspectionVisitor {
+    paramIndex;
+    typeName;
+    bindingName;
+    constructor(paramIndex, typeName, bindingName) {
+        super();
+        this.paramIndex = paramIndex;
+        this.typeName = typeName;
+        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();
+                    }
+                }
+            }
+        }
+    }
+}
+export class TypesReturnAs extends InspectionVisitor {
+    typeName;
+    bindingName;
+    constructor(typeName, bindingName) {
+        super();
+        this.typeName = typeName;
+        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();
+                }
+            }
+        }
+    }
+}
+let Rescues = class Rescues extends ScopedVisitor {
+    exceptionName;
+    constructor(exceptionName, scope) {
+        super(scope);
+        this.exceptionName = exceptionName;
+    }
+    visitCatch(node) {
+        for (const pattern of node.patterns) {
+            if (pattern instanceof VariablePattern &&
+                pattern.name.value === this.exceptionName) {
+                throw new StopTraversalException();
+            }
+        }
+    }
+};
+Rescues = __decorate([
+    AutoScoped
+], Rescues);
+export { Rescues };
+let UsesExceptionHandling = class UsesExceptionHandling extends ScopedVisitor {
+    constructor(scope) {
+        super(scope);
+    }
+    visitTry(node) {
+        throw new StopTraversalException();
+    }
+};
+UsesExceptionHandling = __decorate([
+    AutoScoped
+], UsesExceptionHandling);
+export { UsesExceptionHandling };
+let UsesExceptions = class UsesExceptions extends ScopedVisitor {
+    constructor(scope) {
+        super(scope);
+    }
+    visitTry(node) {
+        return new UsesExceptionHandling(this.binding).visitTry(node);
+    }
+    visitRaise(node) {
+        throw new StopTraversalException();
+    }
+};
+UsesExceptions = __decorate([
+    AutoScoped
+], UsesExceptions);
+export { UsesExceptions };
+export const genericInspections = {
+    Assigns: Assigns,
+    Calls: Calls,
+    Declares: Declares,
+    DeclaresComputation: DeclaresComputation,
+    DeclaresComputationWithArity: DeclaresComputationWithArity,
+    HasArity: DeclaresComputationWithArity,
+    DeclaresEntryPoint: DeclaresEntryPoint,
+    DeclaresFunction: DeclaresFunction,
+    DeclaresRecursively: DeclaresRecursively,
+    HasDirectRecursion: HasDirectRecursion,
+    DeclaresTypeAlias: DeclaresTypeAlias,
+    DeclaresTypeSignature: DeclaresTypeSignature,
+    HasTypeSignature: DeclaresTypeSignature,
+    DeclaresVariable: DeclaresVariable,
+    Raises: Raises,
+    Uses: Uses,
+    HasUsage: Uses,
+    UsesArithmetic: UsesArithmetic,
+    SubordinatesDeclarationsTo: SubordinatesDeclarationsTo,
+    SubordinatesDeclarationsToEntryPoint: SubordinatesDeclarationsToEntryPoint,
+    TypesAs: TypesAs,
+    TypesParameterAs: TypesParameterAs,
+    TypesReturnAs: TypesReturnAs,
+    UsesConditional: UsesConditional,
+    HasConditional: UsesConditional,
+    Rescues: Rescues,
+    UsesExceptionHandling: UsesExceptionHandling,
+    UsesExceptions: UsesExceptions,
+    UsesIf: UsesConditional,
+    UsesLogic: UsesLogic,
+    UsesMath: UsesArithmetic,
+    UsesPrint: UsesPrint,
+    UsesType: UsesType,
+    HasBinding: HasBinding,
+};

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

@@ -0,0 +1,61 @@
+import { Application, Call, Catch, Equation, Function, If, LogicalBinaryOperation, Print, Sequence, SymbolPrimitive, Variable } from "yukigo-ast";
+import { ScopedVisitor, VisitorConstructor } from "../../utils.js";
+export declare class DiscardsExceptions extends ScopedVisitor {
+    visitCatch(node: Catch): void;
+}
+export declare class DoesConsolePrint extends ScopedVisitor {
+    visitPrint(node: Print): void;
+    visitCall(node: Call): void;
+    visitApplication(node: Application): void;
+    private isPrintFunc;
+}
+export declare class HasDeclarationTypos extends ScopedVisitor {
+    visitSequence(node: Sequence): void;
+}
+export declare class HasEmptyIfBranches extends ScopedVisitor {
+    visitIf(node: If): void;
+}
+export declare class HasLongParameterList extends ScopedVisitor {
+    private readonly maxParams;
+    constructor(maxParams?: number, scope?: string);
+    visitEquation(node: Equation): void;
+}
+export declare class HasMisspelledIdentifiers extends ScopedVisitor {
+    private readonly dictionary;
+    constructor(dictionaryWords?: string[], scope?: string);
+    visitVariable(node: Variable): void;
+    visitFunction(node: Function): void;
+    private checkSpelling;
+}
+export declare class HasRedundantBooleanComparison extends ScopedVisitor {
+    visitLogicalBinaryOperation(node: LogicalBinaryOperation): void;
+}
+export declare class HasRedundantIf extends ScopedVisitor {
+    visitIf(node: If): void;
+}
+export declare class HasRedundantLocalVariableReturn extends ScopedVisitor {
+    visitSequence(node: Sequence): void;
+}
+export declare class HasTooShortIdentifiers extends ScopedVisitor {
+    private readonly minLength;
+    constructor(minLength?: number, scope?: string);
+    visitVariable(node: Variable): void;
+}
+export declare class HasUsageTypos extends ScopedVisitor {
+    visitSequence(node: Sequence): void;
+}
+export declare class UsesWrongCaseBindings extends ScopedVisitor {
+    private readonly caseType;
+    constructor(caseType?: string, scopeName?: string);
+    visitSymbolPrimitive(node: SymbolPrimitive): void;
+    private checkCase;
+}
+export declare class IsLongCode extends ScopedVisitor {
+    private readonly maxStatements;
+    constructor(maxStatements?: number, scopeName?: string);
+    visitSequence(node: Sequence): void;
+}
+export declare class ShouldInvertIfCondition extends ScopedVisitor {
+    visitIf(node: If): void;
+}
+export declare const genericSmells: Record<string, VisitorConstructor>;