yukigo 0.1.0 → 0.2.0

package/src/analyzer/inspections/object/smells.ts

@@ -0,0 +1,144 @@
+import {
+  ASTNode,
+  Class,
+  Interface,
+  LogicalBinaryOperation,
+  Method,
+  NilPrimitive,
+  Object,
+  Return,
+  StopTraversalException,
+  StringPrimitive,
+  TraverseVisitor,
+} from "yukigo-ast";
+import { AutoScoped, ScopedVisitor, VisitorConstructor } from "../../utils.js";
+import { Uses } from "../generic/generic.js";
+
+class MethodCollector extends TraverseVisitor {
+  private collectedMethods: Method[] = [];
+  collect(node: Class | Object | Interface): Method[] {
+    node.expression.accept(this);
+    return this.collectedMethods;
+  }
+  visitMethod(node: Method) {
+    this.collectedMethods.push(node);
+  }
+}
+
+@AutoScoped
+export class DoesNilTest extends ScopedVisitor {
+  visitLogicalBinaryOperation(node: LogicalBinaryOperation): void {
+    if (
+      node.left instanceof NilPrimitive ||
+      node.right instanceof NilPrimitive
+    ) {
+      throw new StopTraversalException();
+    }
+  }
+}
+
+@AutoScoped
+export class DoesTypeTest extends ScopedVisitor {
+  visitLogicalBinaryOperation(node: LogicalBinaryOperation): void {
+    if (
+      node.left instanceof StringPrimitive ||
+      node.right instanceof StringPrimitive
+    ) {
+      throw new StopTraversalException();
+    }
+  }
+}
+
+@AutoScoped
+export class ReturnsNil extends ScopedVisitor {
+  visitReturn(node: Return): void {
+    if (!Boolean(node.body) || node.body instanceof NilPrimitive)
+      throw new StopTraversalException();
+  }
+}
+
+@AutoScoped
+export class HasTooManyMethods extends ScopedVisitor {
+  private counter: number;
+  private readonly maxMethods: number;
+
+  constructor(maxMethods: number = 10, scopeName?: string) {
+    super(scopeName);
+    this.maxMethods = maxMethods;
+  }
+
+  visitInterface(node: Interface): void {
+    node.expression.accept(this);
+    this.checkMethodCount();
+    this.counter = 0;
+  }
+
+  visitClass(node: Class): void {
+    node.expression.accept(this);
+    this.checkMethodCount();
+    this.counter = 0;
+  }
+  visitObject(node: Object): void {
+    node.expression.accept(this);
+    this.checkMethodCount();
+    this.counter = 0;
+  }
+
+  visitMethod(node: Method): void {
+    this.counter += 1;
+  }
+
+  private checkMethodCount(): void {
+    if (this.counter > this.maxMethods) throw new StopTraversalException();
+  }
+}
+
+@AutoScoped
+export class OverridesEqualOrHashButNotBoth extends ScopedVisitor {
+  visitClass(node: Class): void {
+    const collector = new MethodCollector();
+    const methods = collector.collect(node);
+    const names = methods.map((m) => m.identifier.value);
+    const hasEquals =
+      names.includes("equals") ||
+      names.includes("==") ||
+      names.includes("eql?");
+
+    const hasHash = names.includes("hashCode") || names.includes("hash");
+
+    if ((hasEquals && !hasHash) || (!hasEquals && hasHash))
+      throw new StopTraversalException();
+  }
+}
+
+@AutoScoped
+export class UsesNamedSelfReference extends ScopedVisitor {
+  visitObject(node: Object): void {
+    this.checkSelfReference(node.identifier.value, node.expression);
+  }
+
+  visitClass(node: Class): void {
+    this.checkSelfReference(node.identifier.value, node.expression);
+  }
+
+  private checkSelfReference(selfName: string, body: ASTNode): void {
+    const checker = new Uses(selfName, this.binding);
+
+    try {
+      body.accept(checker);
+    } catch (e) {
+      if (e instanceof StopTraversalException)
+        throw new StopTraversalException();
+      throw e;
+    }
+  }
+}
+
+export const objectSmells: Record<string, VisitorConstructor> = {
+  DoesNilTest: DoesNilTest,
+  DoesTypeTest: DoesTypeTest,
+  HasTooManyMethods: HasTooManyMethods,
+  OverridesEqualOrHashButNotBoth: OverridesEqualOrHashButNotBoth,
+  ReturnsNil: ReturnsNil,
+  UsesNamedSelfReference: UsesNamedSelfReference,
+};

package/src/analyzer/utils.ts

@@ -1,26 +1,109 @@
-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;
-}
+import {
+  Class,
+  Fact,
+  Function,
+  Method,
+  Object as YuObject,
+  Procedure,
+  Rule,
+  TraverseVisitor,
+  Variable,
+  ASTNode,
+} from "yukigo-ast";
+
+export interface VisitorConstructor {
+  new (...args: any[]): TraverseVisitor & { setBinding?(binding: string): void };
+  IS_INTRANSITIVE?: boolean;
+}
+export type InspectionMap = Record<string, VisitorConstructor>;
+
+type TopNode =
+  | Variable
+  | Function
+  | Class
+  | YuObject
+  | Method
+  | Rule
+  | Fact
+  | Procedure;
+export class ScopedVisitor extends TraverseVisitor {
+  protected binding?: string;
+  public inScope: boolean;
+
+  constructor(binding?: string) {
+    super();
+    this.setBinding(binding)
+  }
+
+  setBinding(binding?: string) {
+    this.binding = binding;
+    this.inScope = !binding;
+  }
+  
+
+  visitVariable(node: Variable): void {
+    this.manageScope(node, () => super.visitVariable(node));
+  }
+  visitFunction(node: Function): void {
+    this.manageScope(node, () => super.visitFunction(node));
+  }
+  visitClass(node: Class): void {
+    this.manageScope(node, () => super.visitClass(node));
+  }
+  visitObject(node: YuObject): void {
+    this.manageScope(node, () => super.visitObject(node));
+  }
+  visitMethod(node: Method): void {
+    this.manageScope(node, () => super.visitMethod(node));
+  }
+  visitRule(node: Rule): void {
+    this.manageScope(node, () => super.visitRule(node));
+  }
+  visitFact(node: Fact): void {
+    this.manageScope(node, () => super.visitFact(node));
+  }
+  visitProcedure(node: Procedure): void {
+    this.manageScope(node, () => super.visitProcedure(node));
+  }
+
+  private manageScope(node: TopNode, traverse: () => void) {
+    const isTarget = node.identifier.value === this.binding;
+    if (isTarget) this.inScope = true;
+    traverse();
+    if (isTarget) this.inScope = false;
+  }
+}
+
+export function AutoScoped<T extends { new (...args: any[]): any }>(
+  constructor: T
+) {
+  const proto = constructor.prototype;
+  const methodNames = Object.getOwnPropertyNames(proto);
+
+  for (const name of methodNames) {
+    if (isValidVisitMethod(name)) {
+      const originalMethod = proto[name];
+
+      // replace the method on the prototype
+      proto[name] = function (this: any, node: ASTNode) {
+        if (!this.inScope) return;
+        // run the inspection logic if in scope
+        return originalMethod.call(this, node);
+      };
+    }
+  }
+}
+function isScopeBoundary(name: string): boolean {
+  return [
+    "visitFunction",
+    "visitMethod",
+    "visitProcedure",
+    "visitRule",
+    "visitFact",
+    "visitVariable",
+    "visitClass",
+    "visitObject",
+  ].includes(name);
+}
+const isValidVisitMethod = (name: string) =>
+  name.startsWith("visit") && name !== "constructor" && !isScopeBoundary(name);

package/src/index.ts

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

package/src/interpreter/components/EnvBuilder.ts

@@ -1,97 +1,202 @@
-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);
-  }
-}
+import {
+  AST,
+  ASTNode,
+  Attribute,
+  Class,
+  EquationRuntime,
+  Fact,
+  Function,
+  isRuntimePredicate,
+  Method,
+  PrimitiveValue,
+  Rule,
+  RuntimeClass,
+  RuntimeFunction,
+  EnvStack,
+  TraverseVisitor,
+  Object,
+  RuntimeObject,
+  Variable,
+  Return,
+  Sequence,
+  SymbolPrimitive,
+  VariablePattern,
+} from "yukigo-ast";
+import { InterpreterVisitor } from "./Visitor.js";
+import { idContinuation, trampoline } from "../trampoline.js";
+import { RuntimeContext } from "./RuntimeContext.js";
+import { InterpreterError } from "../errors.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 {
+  constructor(private ctx: RuntimeContext) {
+    super();
+  }
+  public build(ast: AST) {
+    for (const node of ast) node.accept(this);
+  }
+  visitSequence(node: Sequence): void {
+    for (const stmt of node.statements) stmt.accept(this);
+  }
+  visitFunction(node: Function): void {
+    const name = node.identifier.value;
+
+    if (this.ctx.config.debug)
+      console.log(`[EnvBuilder] Defining function: ${name}`);
+
+    if (node.equations.length === 0)
+      throw new Error(`Function ${name} has no equations`);
+
+    const arity = node.equations[0].patterns.length;
+
+    if (node.equations.some((eq) => eq.patterns.length !== arity))
+      throw new Error(`All equations of ${name} must have the same arity`);
+
+    let placeholder: RuntimeFunction;
+    this.ctx.define(name, placeholder);
+
+    const equations: EquationRuntime[] = node.equations.map((eq) => ({
+      patterns: eq.patterns,
+      body: eq.body,
+    }));
+
+    const runtimeFunc: RuntimeFunction = {
+      type: "Function",
+      identifier: name,
+      arity,
+      equations,
+      closure: this.ctx.env,
+    };
+    this.ctx.define(name, runtimeFunc);
+  }
+  visitClass(node: Class): void {
+    const identifier = node.identifier.value;
+
+    if (this.ctx.config.debug)
+      console.log(`[EnvBuilder] Defining class: ${identifier}`);
+
+    const superclass = node.extendsSymbol?.value;
+
+    const mixins = node.includes.map((symbol) => symbol.value);
+
+    const collector = new OOPCollector();
+    node.expression.accept(collector);
+
+    const fields = collector.collectedFields;
+    const methods = collector.collectedMethods;
+
+    const runtimeClass: RuntimeClass = {
+      type: "Class",
+      identifier,
+      fields,
+      methods,
+      superclass,
+      mixins,
+    };
+
+    this.ctx.define(identifier, runtimeClass);
+  }
+  visitObject(node: Object): void {
+    const identifier = node.identifier.value;
+
+    if (this.ctx.config.debug)
+      console.log(`[EnvBuilder] Defining object: ${identifier}`);
+
+    const collector = new OOPCollector();
+    node.expression.accept(collector);
+
+    const fields = collector.collectedFields;
+    const methods = collector.collectedMethods;
+
+    const runtimeObject: RuntimeObject = {
+      type: "Object",
+      identifier,
+      className: "",
+      fields,
+      methods,
+    };
+
+    this.ctx.define(identifier, runtimeObject);
+  }
+  visitFact(node: Fact): void {
+    const identifier = node.identifier.value;
+
+    if (this.ctx.config.debug)
+      console.log(`[EnvBuilder] Defining fact: ${identifier}`);
+    try {
+      const runtimeValue = this.ctx.lookup(identifier);
+      if (!isRuntimePredicate(runtimeValue))
+        throw new InterpreterError(
+          "EnvBuilder",
+          `"${identifier}" is not a predicate. Maybe there is something else defined as "${identifier}"?`,
+        );
+      runtimeValue.equations.push(node);
+    } catch (error) {
+      this.ctx.define(identifier, {
+        kind: "Predicate",
+        identifier,
+        equations: [node],
+      });
+    }
+  }
+
+  visitRule(node: Rule): void {
+    const identifier = node.identifier.value;
+
+    if (this.ctx.config.debug)
+      console.log(`[EnvBuilder] Defining rule: ${identifier}`);
+    try {
+      const runtimeValue = this.ctx.lookup(identifier);
+      if (!isRuntimePredicate(runtimeValue))
+        throw new InterpreterError(
+          "EnvBuilder",
+          `"${identifier}" is not a predicate. Maybe there is something else defined as "${identifier}"?`,
+        );
+      runtimeValue.equations.push(node);
+    } catch (error) {
+      this.ctx.define(identifier, {
+        kind: "Predicate",
+        identifier,
+        equations: [node],
+      });
+    }
+  }
+  visitVariable(node: Variable): void {
+    const identifier = node.identifier.value;
+
+    if (this.ctx.config.debug)
+      console.log(`[EnvBuilder] Defining variable: ${identifier}`);
+
+    const interpreter = new InterpreterVisitor(this.ctx);
+    const cps = node.expression.accept(interpreter);
+    this.ctx.define(identifier, trampoline(cps(idContinuation)));
+  }
+  visit(node: ASTNode): void {
+    return node.accept(this);
+  }
+}
+
+class OOPCollector extends TraverseVisitor {
+  public collectedMethods: Map<string, RuntimeFunction> = new Map();
+  public collectedFields: Map<string, PrimitiveValue> = new Map();
+  visitMethod(node: Method) {
+    const runtimeMethod: RuntimeFunction = {
+      type: "Function",
+      identifier: node.identifier.value,
+      arity: node.equations[0].patterns.length,
+      equations: node.equations,
+    };
+    this.collectedMethods.set(node.identifier.value, runtimeMethod);
+  }
+
+  visitAttribute(node: Attribute) {
+    this.collectedFields.set(
+      node.identifier.value,
+      InterpreterVisitor.evaluateLiteral(node.expression),
+    );
+  }
+}