method declaration and invoke handling

Author: mattcce

src/ec-evaluator/__tests__/__utils__/utils.ts

@@ -1,51 +1,51 @@
-import { Environment } from "../../components";
-import { STEP_LIMIT } from "../../constants";
-import { ControlItem, Context, StashItem, StructType } from "../../types";
-import { Stack, isNode } from "../../utils";
+import { Environment } from '../../components'
+import { STEP_LIMIT } from '../../constants'
+import { ControlItem, Context, StashItem, StructType } from '../../types'
+import { Stack, isNode } from '../../utils'
 
 export class StackStub<T> extends Stack<T> {
-  private trace: T[] = [];
+  private trace: T[] = []
 
   public push(...items: T[]): void {
     for (const item of items) {
-      super.push(item);
-      this.trace.push(item);
+      super.push(item)
+      this.trace.push(item)
     }
-  };
+  }
 
   public getTrace(): T[] {
-    return this.trace;
-  };
-};
-export class ControlStub extends StackStub<ControlItem> {};
-export class StashStub extends StackStub<StashItem> {};
+    return this.trace
+  }
+}
+export class ControlStub extends StackStub<ControlItem> {}
+export class StashStub extends StackStub<StashItem> {}
 // TODO make env traceable
-export class EnvironmentStub extends Environment {};
+export class EnvironmentStub extends Environment {}
 
 export const createContextStub = (): Context => ({
   errors: [],
   control: new ControlStub(),
   stash: new StashStub(),
   environment: new EnvironmentStub(),
-  totalSteps: STEP_LIMIT,
-});
+  totalSteps: STEP_LIMIT
+})
 
 export const getControlItemStr = (i: ControlItem): string => {
-  return isNode(i) ? i.kind : i.instrType;
-};
+  return isNode(i) ? i.kind : i.instrType
+}
 
 export const getStashItemStr = (i: StashItem): string => {
-  return i.kind === "Literal" 
-    ? i.literalType.value 
+  return i.kind === 'Literal'
+    ? i.literalType.value
     : i.kind === StructType.CLOSURE
-    ? i.mtdOrCon.kind === "MethodDeclaration"
-      ? i.mtdOrCon.methodHeader.identifier
-      : i.mtdOrCon.constructorDeclarator.identifier
-    : i.kind === StructType.VARIABLE
-    ? i.name
-    : i.kind === StructType.CLASS
-    ? i.frame.name
-    : i.kind === StructType.TYPE
-    ? i.type
-    : i.kind;
-};
+      ? i.decl.kind === 'MethodDeclaration' || i.decl.kind === 'NativeDeclaration'
+        ? i.decl.methodHeader.identifier
+        : i.decl.constructorDeclarator.identifier
+      : i.kind === StructType.VARIABLE
+        ? i.name
+        : i.kind === StructType.CLASS
+          ? i.frame.name
+          : i.kind === StructType.TYPE
+            ? i.type
+            : i.kind
+}

src/ec-evaluator/__tests__/natives.test.ts

@@ -1,4 +1,4 @@
-import { natives } from '../natives'
+import { foreigns } from '../natives'
 import {
   //   ControlStub,
   //   StashStub,
@@ -10,10 +10,38 @@ import { parse } from '../../ast/parser'
 import { evaluate } from '../interpreter'
 
 describe('native functions', () => {
-  it('should invoke external native function', () => {
+  it('method declaration should dynamically link foreign function', () => {
     const mockForeignFn = jest.fn()
 
-    natives['testNative(): void'] = mockForeignFn
+    foreigns['C::testNative(): void'] = mockForeignFn
+
+    const programStr = `
+    class C {
+      public native void testNative();
+
+      public static void main(String[] args) {
+          C c = new C();
+          c.testNative();
+      }
+  }
+    `
+
+    const compilationUnit = parse(programStr)
+    expect(compilationUnit).toBeTruthy()
+
+    const context = createContextStub()
+    context.control.push(compilationUnit!)
+
+    evaluate(context)
+
+    const c = context.environment.getClass('C')
+    c.instanceMethods.find(md => md)
+  })
+
+  it('invoke instruction should invoke external native function', () => {
+    const mockForeignFn = jest.fn()
+
+    foreigns['C::testNative(): void'] = mockForeignFn
 
     const programStr = `
     class C {
@@ -42,7 +70,7 @@ describe('native functions', () => {
       expect(s).toBe('"Test"')
     })
 
-    natives['testNative(String s): void'] = foreignFn
+    foreigns['C::testNative(String s): void'] = foreignFn
 
     const programStr = `
     class C {

src/ec-evaluator/interpreter.ts

@@ -65,7 +65,8 @@ import {
   ResConOverloadInstr,
   ResOverrideInstr,
   ResTypeContInstr,
-  StructType
+  StructType,
+  NativeDeclaration
 } from './types'
 import {
   defaultValues,
@@ -87,15 +88,15 @@ import {
   searchMainMtdClass,
   prependExpConInvIfNeeded,
   isStatic,
-  isNative,
+  isNativeMethodDeclaration,
   resOverload,
   resOverride,
   resConOverload,
   isNull,
   makeNonLocalVarNonParamSimpleNameQualified,
   getFullyQualifiedDescriptor
 } from './utils'
-import { natives } from './natives'
+import { foreigns } from './natives'
 
 type CmdEvaluator = (
   command: ControlItem,
@@ -253,9 +254,31 @@ export const cmdEvaluators: { [type: string]: CmdEvaluator } = {
     _control: Control,
     _stash: Stash
   ) => {
+    let mtdClosure
+    // Native method handling
+    if (isNativeMethodDeclaration(command)) {
+      const FQMtdDesc = getFullyQualifiedDescriptor(environment.current.name, command)
+      const fn = foreigns[FQMtdDesc]
+
+      if (fn === undefined) {
+        throw new errors.UndefinedNativeMethod(FQMtdDesc)
+      }
+
+      // bind foreign function
+      const natDecl: NativeDeclaration = {
+        kind: 'NativeDeclaration',
+        methodModifier: command.methodModifier,
+        methodHeader: command.methodHeader,
+        foreignFunction: fn
+      }
+
+      mtdClosure = struct.closureStruct(natDecl, environment.current)
+    } else {
+      mtdClosure = struct.closureStruct(command, environment.current)
+    }
+
     // Use method descriptor as key.
     const mtdDescriptor: string = getDescriptor(command)
-    const mtdClosure = struct.closureStruct(command, environment.current)
     environment.defineMtdOrCon(mtdDescriptor, mtdClosure)
   },
 
@@ -471,13 +494,13 @@ export const cmdEvaluators: { [type: string]: CmdEvaluator } = {
     const closure: Closure = stash.pop()! as Closure
 
     const params: FormalParameter[] =
-      closure.mtdOrCon.kind === 'MethodDeclaration'
-        ? cloneDeep(closure.mtdOrCon.methodHeader.formalParameterList)
-        : cloneDeep(closure.mtdOrCon.constructorDeclarator.formalParameterList)
+      closure.decl.kind === 'MethodDeclaration' || closure.decl.kind === 'NativeDeclaration'
+        ? cloneDeep(closure.decl.methodHeader.formalParameterList)
+        : cloneDeep(closure.decl.constructorDeclarator.formalParameterList)
 
     // Extend env from global frame.
-    const mtdOrConDescriptor = getDescriptor(closure.mtdOrCon)
-    environment.extendEnv(environment.global, mtdOrConDescriptor)
+    const methodDescriptor = getDescriptor(closure.decl)
+    environment.extendEnv(environment.global, methodDescriptor)
 
     const isInstanceMtdOrCon = args.length == params.length + 1
     if (isInstanceMtdOrCon) {
@@ -504,17 +527,10 @@ export const cmdEvaluators: { [type: string]: CmdEvaluator } = {
       environment.defineVariable(params[i].identifier, params[i].unannType, args[i])
     }
 
-    // Native function escape hatch
-    if (closure.mtdOrCon.kind === 'MethodDeclaration' && isNative(closure.mtdOrCon)) {
-      const nativeFnDescriptor = getFullyQualifiedDescriptor(closure.mtdOrCon)
-      const nativeFn = natives[nativeFnDescriptor]
-
-      if (!nativeFn) {
-        throw new errors.UndefinedNativeMethod(nativeFnDescriptor)
-      }
-
-      // call foreign fn
-      nativeFn({ control, stash, environment })
+    // Native functions
+    if (closure.decl.kind === 'NativeDeclaration') {
+      // call foreign fn with CSE machine state
+      closure.decl.foreignFunction({ control, stash, environment })
 
       // only because resetInstr demands one, never actually used
       const superfluousReturnStatement: ReturnStatement = {
@@ -524,15 +540,14 @@ export const cmdEvaluators: { [type: string]: CmdEvaluator } = {
 
       // handle return from native fn
       control.push(instr.resetInstr(superfluousReturnStatement))
-      return
+    } else {
+      // Push method/constructor body.
+      const body =
+        closure.decl.kind === 'MethodDeclaration'
+          ? closure.decl.methodBody
+          : closure.decl.constructorBody
+      control.push(body)
     }
-
-    // Push method/constructor body.
-    const body =
-      closure.mtdOrCon.kind === 'MethodDeclaration'
-        ? closure.mtdOrCon.methodBody
-        : closure.mtdOrCon.constructorBody
-    control.push(body)
   },
 
   [InstrType.ENV]: (
@@ -811,7 +826,7 @@ export const cmdEvaluators: { [type: string]: CmdEvaluator } = {
     stash.push(closure)
 
     // Post-processing required if overload resolved method is instance method.
-    if (isInstance(closure.mtdOrCon as MethodDeclaration)) {
+    if (isInstance(closure.decl as MethodDeclaration)) {
       // Increment arity of InvInstr on control.
       let n = 1
       while (
@@ -834,7 +849,7 @@ export const cmdEvaluators: { [type: string]: CmdEvaluator } = {
     const target = stash.pop()!
     const overloadResolvedClosure = stash.pop()! as Closure
 
-    if (isStatic(overloadResolvedClosure.mtdOrCon as MethodDeclaration)) {
+    if (isStatic(overloadResolvedClosure.decl as MethodDeclaration)) {
       // No method overriding resolution is required if resolved method is a static method.
       stash.push(overloadResolvedClosure)
       return

src/ec-evaluator/natives.ts

@@ -1,4 +1,5 @@
 import { Control, Environment, Stash } from './components'
+import { StashItem } from './types'
 
 /*
     Native function escape hatch.
@@ -14,7 +15,7 @@ import { Control, Environment, Stash } from './components'
     The current implementation automatically injects a return instruction after the external handler function call ends.
 */
 
-export type NativeFunction = ({
+export type ForeignFunction = ({
   control,
   stash,
   environment
@@ -24,6 +25,25 @@ export type NativeFunction = ({
   environment: Environment
 }) => void
 
-export const natives: {
-  [descriptor: string]: NativeFunction
-} = {}
+export const foreigns: {
+  [descriptor: string]: ForeignFunction
+} = {
+  'Object::hashCode(): int': ({ stash }) => {
+    const hashCode = Math.floor(Math.random() * Math.pow(2, 32))
+    const stashItem: StashItem = {
+      kind: 'Literal',
+      literalType: { kind: 'DecimalIntegerLiteral', value: String(hashCode) }
+    }
+
+    console.log(stashItem)
+    stash.push(stashItem)
+  },
+
+  'Object::display(String s): void': ({ environment }) => {
+    // @ts-expect-error ts(2339): guaranteed valid by type checker
+    const s = environment.getVariable('s').value.literalType.value
+
+    // TODO: hook up to frontend
+    console.log(s)
+  }
+}

src/ec-evaluator/structCreator.ts

@@ -6,7 +6,18 @@ import {
   UnannType
 } from '../ast/types/classes'
 import { EnvNode } from './components'
-import { Name, StructType, Type, VarValue, Variable, Symbol, Object, Class, Closure } from './types'
+import {
+  Name,
+  StructType,
+  Type,
+  VarValue,
+  Variable,
+  Symbol,
+  Object,
+  Class,
+  Closure,
+  NativeDeclaration
+} from './types'
 
 export const varStruct = (type: UnannType, name: Name, value: VarValue): Variable => ({
   kind: StructType.VARIABLE,
@@ -27,11 +38,11 @@ export const objStruct = (frame: EnvNode, c: Class): Object => ({
 })
 
 export const closureStruct = (
-  mtdOrCon: MethodDeclaration | ConstructorDeclaration,
+  decl: MethodDeclaration | ConstructorDeclaration | NativeDeclaration,
   env: EnvNode
 ): Closure => ({
   kind: StructType.CLOSURE,
-  mtdOrCon,
+  decl,
   env
 })