yukigo 0.2.3 → 0.3.2

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

@@ -1,149 +0,0 @@
-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 * as Yu from "yukigo-ast";
-import { ScopedVisitor, AutoScoped } from "../../utils.js";
-let UsesComposition = class UsesComposition extends ScopedVisitor {
-    constructor(scope) {
-        super(scope);
-    }
-    visitCompositionExpression(node) {
-        throw new Yu.StopTraversalException();
-    }
-};
-UsesComposition = __decorate([
-    AutoScoped
-], UsesComposition);
-export { UsesComposition };
-let UsesAnonymousVariable = class UsesAnonymousVariable extends ScopedVisitor {
-    constructor(scope) {
-        super(scope);
-    }
-    visitWildcardPattern(node) {
-        throw new Yu.StopTraversalException();
-    }
-};
-UsesAnonymousVariable = __decorate([
-    AutoScoped
-], UsesAnonymousVariable);
-export { UsesAnonymousVariable };
-let UsesComprehension = class UsesComprehension extends ScopedVisitor {
-    constructor(scope) {
-        super(scope);
-    }
-    visitListComprehension(node) {
-        throw new Yu.StopTraversalException();
-    }
-};
-UsesComprehension = __decorate([
-    AutoScoped
-], UsesComprehension);
-export { UsesComprehension };
-let UsesGuards = class UsesGuards extends ScopedVisitor {
-    constructor(scope) {
-        super(scope);
-    }
-    visitGuardedBody(node) {
-        throw new Yu.StopTraversalException();
-    }
-};
-UsesGuards = __decorate([
-    AutoScoped
-], UsesGuards);
-export { UsesGuards };
-let UsesOtherwise = class UsesOtherwise extends ScopedVisitor {
-    constructor(scope) {
-        super(scope);
-    }
-    visitOtherwise(node) {
-        throw new Yu.StopTraversalException();
-    }
-};
-UsesOtherwise = __decorate([
-    AutoScoped
-], UsesOtherwise);
-export { UsesOtherwise };
-let UsesLambda = class UsesLambda extends ScopedVisitor {
-    constructor(scope) {
-        super(scope);
-    }
-    visitLambda(node) {
-        throw new Yu.StopTraversalException();
-    }
-};
-UsesLambda = __decorate([
-    AutoScoped
-], UsesLambda);
-export { UsesLambda };
-let UsesYield = class UsesYield extends ScopedVisitor {
-    constructor(scope) {
-        super(scope);
-    }
-    visitYield(node) {
-        throw new Yu.StopTraversalException();
-    }
-};
-UsesYield = __decorate([
-    AutoScoped
-], UsesYield);
-export { UsesYield };
-let UsesPatternMatching = class UsesPatternMatching extends ScopedVisitor {
-    constructor(scope) {
-        super(scope);
-    }
-    visitConsPattern(node) {
-        throw new Yu.StopTraversalException();
-    }
-    visitAsPattern(node) {
-        throw new Yu.StopTraversalException();
-    }
-    visitListPattern(node) {
-        throw new Yu.StopTraversalException();
-    }
-    visitTuplePattern(node) {
-        throw new Yu.StopTraversalException();
-    }
-    visitLiteralPattern(node) {
-        throw new Yu.StopTraversalException();
-    }
-    visitApplicationPattern(node) {
-        throw new Yu.StopTraversalException();
-    }
-    visitConstructorPattern(node) {
-        throw new Yu.StopTraversalException();
-    }
-    visitUnionPattern(node) {
-        throw new Yu.StopTraversalException();
-    }
-    visitFunctorPattern(node) {
-        throw new Yu.StopTraversalException();
-    }
-    visitWildcardPattern(node) {
-        throw new Yu.StopTraversalException();
-    }
-};
-UsesPatternMatching = __decorate([
-    AutoScoped
-], UsesPatternMatching);
-export { UsesPatternMatching };
-export const functionalInspections = {
-    UsesComposition: UsesComposition,
-    HasComposition: UsesComposition,
-    UsesAnonymousVariable: UsesAnonymousVariable,
-    HasAnonymousVariable: UsesAnonymousVariable,
-    UsesComprehension: UsesComprehension,
-    HasComprehension: UsesComprehension,
-    UsesGuards: UsesGuards,
-    HasGuards: UsesGuards,
-    UsesOtherwise: UsesOtherwise,
-    HasOtherwise: UsesOtherwise,
-    UsesLambda: UsesLambda,
-    HasLambda: UsesLambda,
-    UsesYield: UsesYield,
-    HasYield: UsesYield,
-    UsesPatternMatching: UsesPatternMatching,
-    HasPatternMatching: UsesPatternMatching,
-};

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

@@ -1,16 +0,0 @@
-import { Lambda, Equation, GuardedBody } 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;
-    private isAlwaysTrue;
-}
-export declare class ShouldUseOtherwise extends ScopedVisitor {
-    visitGuardedBody(node: GuardedBody): void;
-}
-export declare class HasRedundantParameter extends ScopedVisitor {
-    visitEquation(node: Equation): void;
-}
-export declare const functionalSmells: Record<string, VisitorConstructor>;

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

@@ -1,98 +0,0 @@
-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

@@ -1,178 +0,0 @@
-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>;