yukigo 0.2.0 → 0.2.3

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

@@ -0,0 +1,98 @@
+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 { Call, VariablePattern, Variable, StopTraversalException, BooleanPrimitive, Application, isUnguardedBody, 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))
+            return;
+        const param = node.parameters[0];
+        const call = node.body;
+        if (call.functionExpr instanceof Application ||
+            call.functionExpr instanceof Call)
+            return;
+        const arg = call.parameter;
+        if (param instanceof VariablePattern &&
+            arg instanceof Variable &&
+            param.name.value === arg.identifier.value)
+            throw new StopTraversalException();
+    }
+};
+HasRedundantLambda = __decorate([
+    AutoScoped
+], 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();
+        }
+    }
+    isAlwaysTrue(node) {
+        // check for boolean literal 'True'
+        if (node instanceof BooleanPrimitive && node.value === true)
+            return true;
+        // check for default case
+        if (node instanceof Otherwise)
+            return true;
+        return false;
+    }
+};
+HasRedundantGuards = __decorate([
+    AutoScoped
+], HasRedundantGuards);
+export { HasRedundantGuards };
+let ShouldUseOtherwise = class ShouldUseOtherwise extends ScopedVisitor {
+    visitGuardedBody(node) {
+        if (node.condition instanceof BooleanPrimitive &&
+            node.condition.value === true)
+            throw new StopTraversalException();
+    }
+};
+ShouldUseOtherwise = __decorate([
+    AutoScoped
+], ShouldUseOtherwise);
+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;
+                }
+            }
+        }
+    }
+};
+HasRedundantParameter = __decorate([
+    AutoScoped
+], HasRedundantParameter);
+export { HasRedundantParameter };
+export const functionalSmells = {
+    HasRedundantGuards: HasRedundantGuards,
+    HasRedundantLambda: HasRedundantLambda,
+    HasRedundantParameter: HasRedundantParameter,
+    ShouldUseOtherwise: ShouldUseOtherwise,
+};

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

@@ -0,0 +1,178 @@
+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, 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);
+    visitVariable(node: Variable): void;
+    visitAttribute(node: Attribute): void;
+    visitAssignment(node: Assignment): void;
+}
+export declare class Calls extends ScopedVisitor {
+    private readonly targetCallee;
+    constructor(targetCallee: string, scope?: string);
+    visitCall(node: Call): void;
+}
+export declare class Declares extends ScopedVisitor {
+    private readonly targetIdentifier;
+    constructor(targetIdentifier: string, scopeName?: string);
+    private check;
+    visitFunction(node: Function): void;
+    visitMethod(node: Method): void;
+    visitProcedure(node: Procedure): void;
+    visitRule(node: Rule): void;
+    visitFact(node: Fact): void;
+    visitVariable(node: Variable): void;
+    visitAttribute(node: Attribute): void;
+    visitTypeAlias(node: TypeAlias): void;
+    visitTypeSignature(node: TypeSignature): void;
+}
+export declare class DeclaresComputation extends ScopedVisitor {
+    private readonly callName;
+    constructor(callName: string, scope?: string);
+    visitFunction(node: Function): void;
+    visitMethod(node: Method): void;
+    visitProcedure(node: Procedure): void;
+    visitFact(node: Fact): void;
+    visitRule(node: Rule): void;
+}
+export declare class DeclaresComputationWithArity extends ScopedVisitor {
+    private readonly targetArity;
+    constructor(targetArity: string, scope?: string);
+    visitFunction(node: Function): void;
+    visitMethod(node: Method): void;
+    visitProcedure(node: Procedure): void;
+    visitFact(node: Fact): void;
+    visitRule(node: Rule): void;
+}
+export declare class DeclaresEntryPoint extends InspectionVisitor {
+    visitEntryPoint(node: EntryPoint): void;
+}
+export declare class DeclaresFunction extends ScopedVisitor {
+    private readonly targetBinding;
+    constructor(targetBinding: string, scope?: string);
+    visitFunction(node: Function): void;
+}
+export declare class DeclaresRecursively extends ScopedVisitor {
+    private readonly targetBinding;
+    constructor(targetBinding: string, scope?: string);
+    visitFunction(node: Function): void;
+    visitMethod(node: Method): void;
+    visitProcedure(node: Procedure): void;
+    visitFact(node: Fact): void;
+    visitRule(node: Rule): void;
+    visitNested(node: ASTNode): void;
+}
+export declare class HasDirectRecursion extends InspectionVisitor {
+    private readonly binding;
+    private isInsideBody;
+    constructor(binding: string);
+    visitFunction(node: Function): void;
+    visitRule(node: Rule): void;
+    visitProcedure(node: Procedure): void;
+    visitMethod(node: Method): void;
+    visitEquation(node: Equation): void;
+    visitSymbolPrimitive(node: SymbolPrimitive): void;
+}
+export declare class DeclaresTypeAlias extends InspectionVisitor {
+    private readonly typeAliasName;
+    constructor(typeAliasName: string);
+    visitTypeAlias(node: TypeAlias): void;
+}
+export declare class DeclaresTypeSignature extends InspectionVisitor {
+    private readonly targetBinding;
+    constructor(targetBinding: string);
+    visitTypeSignature(node: TypeSignature): void;
+}
+export declare class DeclaresVariable extends ScopedVisitor {
+    private readonly targetBinding;
+    constructor(targetBinding: string, scope?: string);
+    visitVariable(node: Variable): void;
+}
+export declare class Raises extends ScopedVisitor {
+    constructor(scope: string);
+    visitRaise(node: Raise): void;
+}
+export declare class Uses extends ScopedVisitor {
+    private readonly targetBinding;
+    constructor(targetBinding: string, scope?: string);
+    visitSymbolPrimitive(node: SymbolPrimitive): void;
+}
+export declare class UsesArithmetic extends ScopedVisitor {
+    constructor(scope?: string);
+    visitArithmeticBinaryOperation(node: ArithmeticBinaryOperation): void;
+    visitArithmeticUnaryOperation(node: ArithmeticUnaryOperation): void;
+}
+export declare class UsesConditional extends ScopedVisitor {
+    visitIf(node: If): void;
+}
+export declare class UsesLogic extends ScopedVisitor {
+    constructor(scope?: string);
+    visitLogicalBinaryOperation(node: LogicalBinaryOperation): void;
+    visitLogicalUnaryOperation(node: LogicalUnaryOperation): void;
+}
+export declare class UsesPrint extends ScopedVisitor {
+    constructor(scope?: string);
+    visitPrint(node: Print): void;
+}
+export declare class UsesType extends ScopedVisitor {
+    private readonly targetBinding;
+    constructor(targetBinding: string, scope?: string);
+    visitTypeSignature(node: TypeSignature): void;
+    visitSimpleType(node: SimpleType): void;
+    visitTypeVar(node: TypeVar): void;
+}
+export declare class HasBinding extends ScopedVisitor {
+    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;
+}
+export declare class SubordinatesDeclarationsTo extends InspectionVisitor {
+    private childName;
+    private parentName;
+    constructor(childName: string, parentName: string);
+    visitFunction(node: Function): void;
+}
+export declare class SubordinatesDeclarationsToEntryPoint extends InspectionVisitor {
+    private childName;
+    constructor(childName: string);
+    visitEntryPoint(node: EntryPoint): void;
+}
+export declare class TypesAs extends InspectionVisitor {
+    private typeName;
+    private bindingName;
+    constructor(typeName: string, bindingName: string);
+    visitTypeSignature(node: TypeSignature): void;
+}
+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 InspectionVisitor {
+    private typeName;
+    private bindingName;
+    constructor(typeName: string, bindingName: string);
+    visitTypeSignature(node: TypeSignature): void;
+}
+export declare class Rescues extends ScopedVisitor {
+    private exceptionName;
+    constructor(exceptionName: string, scope?: string);
+    visitCatch(node: Catch): void;
+}
+export declare class UsesExceptionHandling extends ScopedVisitor {
+    constructor(scope?: string);
+    visitTry(node: Try): void;
+}
+export declare class UsesExceptions extends ScopedVisitor {
+    constructor(scope?: string);
+    visitTry(node: Try): void;
+    visitRaise(node: Raise): void;
+}
+export declare const genericInspections: Record<string, VisitorConstructor>;