yukigo 0.1.0

package/src/analyzer/inspections/logic.ts

@@ -0,0 +1,166 @@
+import {
+  Assignment,
+  AssignOperation,
+  Exist,
+  Fact,
+  Findall,
+  Forall,
+  Not,
+  Rule,
+  StopTraversalException,
+  SymbolPrimitive,
+  TraverseVisitor,
+  UnifyOperation,
+} from "yukigo-ast";
+import { InspectionMap, executeVisitor } from "../utils.js";
+import { isYukigoPrimitive } from "yukigo-ast";
+
+export abstract class DeclaresBinding extends TraverseVisitor {
+  protected readonly targetBinding: string;
+
+  constructor(binding: string) {
+    super();
+    this.targetBinding = binding;
+  }
+}
+export class DeclaresFact extends DeclaresBinding {
+  visitFact(node: Fact): void {
+    const bindingName = node.identifier.value;
+    if (!this.targetBinding || bindingName === this.targetBinding)
+      throw new StopTraversalException();
+  }
+}
+export class DeclaresRule extends DeclaresBinding {
+  visitRule(node: Rule): void {
+    const bindingName = node.identifier.value;
+    if (!this.targetBinding || bindingName === this.targetBinding)
+      throw new StopTraversalException();
+  }
+}
+export class DeclaresPredicate extends DeclaresBinding {
+  visitFact(node: Fact): void {
+    new DeclaresFact(this.targetBinding).visitFact(node);
+  }
+  visitRule(node: Rule): void {
+    new DeclaresRule(this.targetBinding).visitRule(node);
+  }
+}
+
+export class PredicateVisitor extends TraverseVisitor {
+  private readonly targetBinding: string;
+  protected isInsideTargetScope: boolean = false; // this flag helps to check nested functions inside the targetBinding scope
+  constructor(binding: string) {
+    super();
+    this.targetBinding = binding;
+  }
+  visitFact(node: Fact): void {
+    const nodeName = node.identifier.value;
+    if (!this.isInsideTargetScope) {
+      if (nodeName === this.targetBinding) {
+        this.isInsideTargetScope = true;
+        this.traverseCollection(node.patterns);
+        this.isInsideTargetScope = false;
+      }
+      return;
+    }
+    this.traverseCollection(node.patterns);
+  }
+  visitRule(node: Rule): void {
+    const nodeName = node.identifier.value;
+    if (!this.isInsideTargetScope) {
+      if (nodeName === this.targetBinding) {
+        this.isInsideTargetScope = true;
+        this.traverseCollection(node.expressions);
+        this.isInsideTargetScope = false;
+      }
+      return;
+    }
+    this.traverseCollection(node.expressions);
+  }
+}
+
+export class UsesFindall extends TraverseVisitor {
+  visitFindall(node: Findall): void {
+    throw new StopTraversalException();
+  }
+}
+export class UsesForall extends TraverseVisitor {
+  visitForall(node: Forall): void {
+    throw new StopTraversalException();
+  }
+}
+export class UsesNot extends TraverseVisitor {
+  visitNot(node: Not): void {
+    throw new StopTraversalException();
+  }
+  visitExist(node: Exist): void {
+    if (node.identifier.value === "not") throw new StopTraversalException();
+  }
+}
+export class UsesUnificationOperator extends PredicateVisitor {
+  visitUnifyOperation(node: UnifyOperation): void {
+    throw new StopTraversalException();
+  }
+}
+export class UsesCut extends PredicateVisitor {
+  visitExist(node: Exist): void {
+    if (node.identifier.value === "!") throw new StopTraversalException();
+  }
+}
+export class UsesFail extends PredicateVisitor {
+  visitExist(node: Exist): void {
+    if (node.identifier.value === "fail") throw new StopTraversalException();
+  }
+}
+export class HasRedundantReduction extends TraverseVisitor {
+  private readonly targetBinding: string;
+  protected isInsideTargetScope: boolean = false;
+
+  constructor(binding: string) {
+    super();
+    this.targetBinding = binding;
+  }
+  visitRule(node: Rule): void {
+    // Only inspect the specified rule if a binding is provided
+    if (this.targetBinding && node.identifier.value !== this.targetBinding)
+      return;
+
+    // Check each unification in the rule's body
+    for (const bodyElement of node.expressions) {
+      if (bodyElement instanceof AssignOperation) {
+        const left = bodyElement.left;
+        const right = bodyElement.right;
+
+        if (!(left instanceof SymbolPrimitive)) continue;
+
+        const redundantReductionParameters = isYukigoPrimitive(right);
+        const redundantReductionFunctors = right instanceof Exist;
+
+        // Check if reduction is redundant
+        const isRedundant =
+          redundantReductionParameters || redundantReductionFunctors;
+
+        if (isRedundant) throw new StopTraversalException();
+      }
+    }
+  }
+}
+
+export const logicInspections: InspectionMap = {
+  DeclaresFact: (node, args, binding) =>
+    executeVisitor(node, new DeclaresFact(binding)),
+  DeclaresRule: (node, args, binding) =>
+    executeVisitor(node, new DeclaresRule(binding)),
+  DeclaresPredicate: (node, args, binding) =>
+    executeVisitor(node, new DeclaresPredicate(binding)),
+  UsesFindall: (node, args, binding) => executeVisitor(node, new UsesFindall()),
+  UsesForall: (node, args, binding) => executeVisitor(node, new UsesForall()),
+  UsesNot: (node, args, binding) => executeVisitor(node, new UsesNot()),
+  UsesUnificationOperator: (node, args, binding) =>
+    executeVisitor(node, new UsesUnificationOperator(binding)),
+  UsesCut: (node, args, binding) => executeVisitor(node, new UsesCut(binding)),
+  UsesFail: (node, args, binding) =>
+    executeVisitor(node, new UsesFail(binding)),
+  HasRedundantReduction: (node, args, binding) =>
+    executeVisitor(node, new HasRedundantReduction(binding)),
+};

package/src/analyzer/inspections/object.ts

@@ -0,0 +1,282 @@
+import {
+  Attribute,
+  Class,
+  Include,
+  Interface,
+  Method,
+  New,
+  Object,
+  PrimitiveMethod,
+  Self,
+  Send,
+  StopTraversalException,
+  SymbolPrimitive,
+  TraverseVisitor,
+} from "yukigo-ast";
+import { executeVisitor, InspectionMap } from "../utils.js";
+
+export class DeclaresAttribute extends TraverseVisitor {
+  constructor(private attributeName: string) {
+    super();
+  }
+  visitAttribute(node: Attribute): void {
+    if (node.identifier.value === this.attributeName)
+      throw new StopTraversalException();
+  }
+}
+
+export class DeclaresClass extends TraverseVisitor {
+  constructor(private className: string) {
+    super();
+  }
+  visitClass(node: Class): void {
+    if (node.identifier.value === this.className)
+      throw new StopTraversalException();
+  }
+}
+
+export class DeclaresInterface extends TraverseVisitor {
+  constructor(private interfaceName: string) {
+    super();
+  }
+  visitInterface(node: Interface): void {
+    if (node.identifier.value === this.interfaceName)
+      throw new StopTraversalException();
+  }
+}
+
+export class DeclaresMethod extends TraverseVisitor {
+  constructor(private methodName: string) {
+    super();
+  }
+  visitMethod(node: Method): void {
+    if (node.identifier.value === this.methodName)
+      throw new StopTraversalException();
+  }
+}
+
+export class DeclaresObject extends TraverseVisitor {
+  constructor(private objectName: string) {
+    super();
+  }
+  visitObject(node: Object): void {
+    if (node.identifier.value === this.objectName)
+      throw new StopTraversalException();
+  }
+}
+
+export class DeclaresPrimitive extends TraverseVisitor {
+  constructor(private operatorName: string) {
+    super();
+  }
+  visitPrimitiveMethod(node: PrimitiveMethod): void {
+    if (node.operator === this.operatorName) throw new StopTraversalException();
+  }
+}
+
+export class DeclaresSuperclass extends TraverseVisitor {
+  constructor(private superclassName: string) {
+    super();
+  }
+  visitClass(node: Class): void {
+    if (node.extendsSymbol && node.extendsSymbol.value === this.superclassName)
+      throw new StopTraversalException();
+  }
+}
+
+export class Implements extends TraverseVisitor {
+  constructor(private interfaceName: string) {
+    super();
+  }
+  visitClass(node: Class): void {
+    if (
+      node.implementsNode &&
+      node.implementsNode.identifier.value === this.interfaceName
+    )
+      throw new StopTraversalException();
+  }
+}
+
+export class IncludeMixin extends TraverseVisitor {
+  constructor(private mixinsName: string) {
+    super();
+  }
+  visitInclude(node: Include): void {
+    if (node.identifier.value === this.mixinsName)
+      throw new StopTraversalException();
+  }
+}
+
+export class Instantiates extends TraverseVisitor {
+  constructor(private className: string) {
+    super();
+  }
+  visitNew(node: New): void {
+    if (node.identifier.value === this.className)
+      throw new StopTraversalException();
+  }
+}
+
+export class UsesDynamicPolymorphism extends TraverseVisitor {
+  private count = 0;
+
+  constructor(private selectorName: string) {
+    super();
+  }
+
+  visitMethod(node: Method): void {
+    if (node.identifier.value === this.selectorName) {
+      this.count++;
+      if (this.count >= 2) throw new StopTraversalException();
+    }
+  }
+}
+
+export class UsesInheritance extends TraverseVisitor {
+  visitClass(node: Class): void {
+    if (node.extendsSymbol) throw new StopTraversalException();
+  }
+  visitInterface(node: Interface): void {
+    if (node.extendsSymbol && node.extendsSymbol.length > 0)
+      throw new StopTraversalException();
+  }
+}
+
+export class UsesMixins extends TraverseVisitor {
+  visitInclude(node: Include): void {
+    throw new StopTraversalException();
+  }
+}
+
+export class UsesObjectComposition extends TraverseVisitor {
+  visitAttribute(node: Attribute): void {
+    if (node.expression instanceof New) throw new StopTraversalException();
+  }
+}
+
+export class UsesStaticMethodOverload extends TraverseVisitor {
+  private scopes: Set<string>[] = [];
+
+  visitClass(node: Class): void {
+    this.scopes.push(new Set());
+    node.expression.accept(this);
+    this.scopes.pop();
+  }
+
+  visitObject(node: Object): void {
+    this.scopes.push(new Set());
+    node.expression.accept(this);
+    this.scopes.pop();
+  }
+
+  visitMethod(node: Method): void {
+    const currentScope = this.scopes[0];
+    const methodName = node.identifier.value;
+
+    if (currentScope.has(methodName)) throw new StopTraversalException();
+    currentScope.add(methodName);
+  }
+}
+
+export class UsesDynamicMethodOverload extends TraverseVisitor {
+  visitMethod(node: Method): void {
+    if (node.equations.length > 1) throw new StopTraversalException();
+  }
+}
+
+class AbstractMethodCollector extends TraverseVisitor {
+  public abstractMethods: Set<string> = new Set();
+
+  visitMethod(node: Method): void {
+    if (node.getMetadata<boolean>("isAbstract") === true)
+      this.abstractMethods.add(node.identifier.value);
+  }
+  // stop propagation to not mix scopes
+  visitClass(node: Class) {
+    return;
+  }
+  visitObject(node: Object) {
+    return;
+  }
+}
+
+export class UsesTemplateMethod extends TraverseVisitor {
+  private abstractMethodsStack: Set<string>[] = [];
+
+  visitClass(node: Class): void {
+    const collector = new AbstractMethodCollector();
+    if (node.expression) executeVisitor(node.expression, collector);
+    this.abstractMethodsStack.push(collector.abstractMethods);
+    node.expression.accept(this);
+    this.abstractMethodsStack.pop();
+  }
+
+  visitSend(node: Send): void {
+    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();
+    }
+  }
+}
+
+export const objectInspections: InspectionMap = {
+  DeclaresAttribute: (node, args) =>
+    executeVisitor(node, new DeclaresAttribute(args[0])),
+
+  DeclaresClass: (node, args) =>
+    executeVisitor(node, new DeclaresClass(args[0])),
+
+  DeclaresInterface: (node, args) =>
+    executeVisitor(node, new DeclaresInterface(args[0])),
+
+  DeclaresMethod: (node, args) =>
+    executeVisitor(node, new DeclaresMethod(args[0])),
+
+  DeclaresObject: (node, args) =>
+    executeVisitor(node, new DeclaresObject(args[0])),
+
+  DeclaresPrimitive: (node, args) =>
+    executeVisitor(node, new DeclaresPrimitive(args[0])),
+
+  DeclaresSuperclass: (node, args) =>
+    executeVisitor(node, new DeclaresSuperclass(args[0])),
+
+  Implements: (node, args) => executeVisitor(node, new Implements(args[0])),
+
+  Include: (node, args) => executeVisitor(node, new IncludeMixin(args[0])),
+
+  Inherits: (node, args) =>
+    executeVisitor(node, new DeclaresSuperclass(args[0])),
+
+  Instantiates: (node, args) => executeVisitor(node, new Instantiates(args[0])),
+
+  UsesDynamicPolymorphism: (node, args) =>
+    executeVisitor(node, new UsesDynamicPolymorphism(args[0])),
+
+  UsesInheritance: (node, args) => executeVisitor(node, new UsesInheritance()),
+
+  UsesMixins: (node, args) => executeVisitor(node, new UsesMixins()),
+
+  UsesObjectComposition: (node, args) =>
+    executeVisitor(node, new UsesObjectComposition()),
+
+  UsesStaticMethodOverload: (node, args) =>
+    executeVisitor(node, new UsesStaticMethodOverload()),
+
+  UsesDynamicMethodOverload: (node, args) =>
+    executeVisitor(node, new UsesDynamicMethodOverload()),
+
+  UsesTemplateMethod: (node, args) =>
+    executeVisitor(node, new UsesTemplateMethod()),
+
+  UsesStaticPolymorphism: (node, args) =>
+    executeVisitor(node, new UsesStaticMethodOverload()),
+};

package/src/analyzer/utils.ts

@@ -0,0 +1,26 @@
+import { ASTNode, StopTraversalException, TraverseVisitor } from "yukigo-ast";
+
+export type InspectionHandler = (
+  node: ASTNode,
+  args: string[],
+  binding?: string
+) => boolean;
+
+export type InspectionMap = Record<string, InspectionHandler>;
+
+export function executeVisitor(
+  node: ASTNode,
+  visitor: TraverseVisitor
+): boolean {
+  let passes = false;
+  try {
+    node.accept(visitor);
+  } catch (e) {
+    if (e instanceof StopTraversalException) {
+      passes = true;
+    } else {
+      throw e;
+    }
+  }
+  return passes;
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from "./interpreter/index.js";
+export * from "./analyzer/index.js";
+export * from "./utils/helpers.js";

package/src/interpreter/components/EnvBuilder.ts

@@ -0,0 +1,97 @@
+import {
+  AST,
+  ASTNode,
+  EquationRuntime,
+  Fact,
+  Function,
+  isRuntimePredicate,
+  Rule,
+  RuntimeFunction,
+  TraverseVisitor,
+} from "yukigo-ast";
+import { EnvStack } from "../index.js";
+import { define } from "../utils.js";
+
+/**
+ * Builds the initial environment by collecting all top-level function declarations.
+ * Each function captures a closure of the environment at its definition time,
+ * allowing recursion by including itself in the closure.
+ */
+export class EnvBuilderVisitor extends TraverseVisitor {
+  private env: EnvStack;
+
+  constructor(baseEnv?: EnvStack) {
+    super();
+    this.env = baseEnv ?? [new Map()];
+  }
+
+  public build(ast: AST): EnvStack {
+    for (const node of ast) node.accept(this);
+    return this.env;
+  }
+  visitFunction(node: Function): void {
+    const name = node.identifier.value;
+
+    if (node.equations.length === 0)
+      throw new Error(`Function ${name} has no equations`);
+
+    const arity = node.equations[0].patterns.length;
+    for (const eq of node.equations) {
+      if (eq.patterns.length !== arity)
+        throw new Error(`All equations of ${name} must have the same arity`);
+    }
+
+    let placeholder: RuntimeFunction;
+    define(this.env, name, placeholder);
+
+    const equations: EquationRuntime[] = node.equations.map((eq) => ({
+      patterns: eq.patterns,
+      body: eq.body,
+    }));
+
+    const runtimeFunc: RuntimeFunction = {
+      identifier: name,
+      arity,
+      equations,
+    };
+    define(this.env, name, runtimeFunc);
+  }
+  visitFact(node: Fact): void {
+    const identifier = node.identifier.value;
+    const runtimeValue = this.env[0].get(identifier);
+
+    if (isRuntimePredicate(runtimeValue) && runtimeValue.kind === "Fact") {
+      this.env[0].set(identifier, {
+        ...runtimeValue,
+        equations: [...runtimeValue.equations, node],
+      });
+    } else {
+      this.env[0].set(identifier, {
+        kind: "Fact",
+        identifier,
+        equations: [node],
+      });
+    }
+  }
+
+  visitRule(node: Rule): void {
+    const identifier = node.identifier.value;
+    const runtimeValue = this.env[0].get(identifier);
+
+    if (isRuntimePredicate(runtimeValue) && runtimeValue.kind === "Rule") {
+      this.env[0].set(identifier, {
+        ...runtimeValue,
+        equations: [...runtimeValue.equations, node],
+      });
+    } else {
+      this.env[0].set(identifier, {
+        kind: "Rule",
+        identifier,
+        equations: [node],
+      });
+    }
+  }
+  visit(node: ASTNode): void {
+    return node.accept(this);
+  }
+}

package/src/interpreter/components/FunctionRuntime.ts

@@ -0,0 +1,79 @@
+import {
+  EquationRuntime,
+  PrimitiveValue,
+  UnguardedBody,
+  Sequence,
+  Return,
+  Expression,
+} from "yukigo-ast";
+import { Bindings, EnvStack } from "../index.js";
+import { PatternMatcher } from "./PatternMatcher.js";
+import { ExpressionEvaluator } from "../utils.js";
+import { InterpreterError } from "../errors.js";
+
+class NonExhaustivePatterns extends InterpreterError {
+  constructor(funcName: string) {
+    super("PatternMatch", `Non-exhaustive patterns in '${funcName}'`);
+  }
+}
+
+export class FunctionRuntime {
+  static apply(
+    funcName: string,
+    equations: EquationRuntime[],
+    args: PrimitiveValue[],
+    currentEnv: EnvStack,
+    evaluatorFactory: (env: EnvStack) => ExpressionEvaluator
+  ): PrimitiveValue {
+    for (const eq of equations) {
+      if (eq.patterns.length !== args.length) continue;
+
+      const bindings: Bindings = [];
+
+      if (!FunctionRuntime.patternsMatch(eq, args, bindings)) continue;
+      const localEnv = new Map<string, PrimitiveValue>(bindings);
+      const newStack: EnvStack = [localEnv, ...currentEnv];
+
+      const scopeEvaluator = evaluatorFactory(newStack);
+
+      // UnguardedBody
+      if (eq.body instanceof UnguardedBody)
+        return this.evaluateSequence(eq.body.sequence, scopeEvaluator);
+
+      // GuardedBody
+      for (const guard of eq.body) {
+        const cond = scopeEvaluator.evaluate(guard.condition);
+        if (cond === true) return scopeEvaluator.evaluate(guard.body);
+      }
+    }
+    throw new NonExhaustivePatterns(funcName);
+  }
+
+  private static patternsMatch(
+    eq: EquationRuntime,
+    args: PrimitiveValue[],
+    bindings: Bindings
+  ): boolean {
+    for (let i = 0; i < args.length; i++) {
+      const matcher = new PatternMatcher(args[i], bindings);
+      if (!eq.patterns[i].accept(matcher)) return false;
+    }
+    return true;
+  }
+
+  private static evaluateSequence(
+    seq: Sequence,
+    evaluator: ExpressionEvaluator
+  ): PrimitiveValue {
+    let result: PrimitiveValue = undefined;
+
+    for (const stmt of seq.statements) {
+      if (stmt instanceof Return) {
+        return evaluator.evaluate(stmt.body);
+      } else {
+        result = evaluator.evaluate(stmt);
+      }
+    }
+    return result;
+  }
+}