vmExprFunction.go

package vm

import (
	"context"
	"fmt"
	"reflect"

	"github.com/dgrr/pako/ast"
)

func (runInfo *runInfoStruct) funcType(params int, styp reflect.Type, hasRecv, varArg bool) reflect.Type {
	n := 1
	if hasRecv {
		n++
	}
	// create the inTypes needed by reflect.FuncOf
	inTypes := make([]reflect.Type, params+n)
	// for runVMFunction first arg is always context
	inTypes[0] = contextType
	if hasRecv { // if has a recv then the second arg should be a vmStruct
		inTypes[1] = vmStructType
	}
	for i := n; i < len(inTypes); i++ {
		inTypes[i] = reflectValueType
	}
	if varArg {
		inTypes[len(inTypes)-1] = interfaceSliceType
	}

	// create funcType, output is always slice of reflect.Type with two values
	return reflect.FuncOf(inTypes, []reflect.Type{reflectValueType, reflectValueType}, varArg)
}

// funcExpr creates a function that reflect Call can use.
// When called, it will run runVMFunction, to run the function statements
func (runInfo *runInfoStruct) funcExpr() reflect.Type {
	funcExpr := runInfo.expr.(*ast.FuncExpr)
	hasRecv := funcExpr.Recv != ""

	var styp reflect.Type
	if hasRecv {
		styp, _ = runInfo.env.Type(funcExpr.Recv)
	}
	funcType := runInfo.funcType(len(funcExpr.Params), styp, hasRecv, funcExpr.VarArg)

	// for adding env into saved function
	envFunc := runInfo.env
	vmTypes := runInfo.vmTypes

	// create a function that can be used by reflect.MakeFunc
	// this function is a translator that converts a function call into a vm run
	// returns slice of reflect.Type with two values:
	// return value of the function and error value of the run
	runVMFunction := func(in []reflect.Value) []reflect.Value {
		runInfo := runInfoStruct{ctx: in[0].Interface().(context.Context), options: runInfo.options, env: envFunc.NewEnv(), stmt: funcExpr.Stmt, rv: nilValue, vmTypes: vmTypes}
		in = in[1:]
		if hasRecv { // is a method
			runInfo.rv = in[0].Interface().(*vmStruct).v
			runInfo.env.DefineValue("self", runInfo.rv)
			in = in[1:]
		}

		// add Params to newEnv, except last Params
		for i := 0; i < len(funcExpr.Params)-1; i++ {
			runInfo.rv = in[i].Interface().(reflect.Value)
			runInfo.env.DefineValue(funcExpr.Params[i], runInfo.rv)
		}
		// add last Params to newEnv
		if len(funcExpr.Params) > 0 {
			if funcExpr.VarArg {
				// function is variadic, add last Params to newEnv without convert to Interface and then reflect.Value
				runInfo.rv = in[len(funcExpr.Params)-1]
				runInfo.env.DefineValue(funcExpr.Params[len(funcExpr.Params)-1], runInfo.rv)
			} else {
				// function is not variadic, add last Params to newEnv
				runInfo.rv = in[len(funcExpr.Params)-1].Interface().(reflect.Value)
				runInfo.env.DefineValue(funcExpr.Params[len(funcExpr.Params)-1], runInfo.rv)
			}
		}

		// run function statements
		runInfo.runSingleStmt()
		if runInfo.err != nil && runInfo.err != ErrReturn {
			runInfo.err = newError(funcExpr, runInfo.err)
			// return nil value and error
			// need to do single reflect.ValueOf because nilValue is already reflect.Value of nil
			// need to do double reflect.ValueOf of newError in order to match
			return []reflect.Value{reflectValueNilValue, reflect.ValueOf(reflect.ValueOf(newError(funcExpr, runInfo.err)))}
		}

		// the reflect.ValueOf of rv is needed to work in the reflect.Value slice
		// reflectValueErrorNilValue is already a double reflect.ValueOf
		return []reflect.Value{reflect.ValueOf(runInfo.rv), reflectValueErrorNilValue}
	}

	// make the reflect.Value function that calls runVMFunction
	runInfo.rv = reflect.MakeFunc(funcType, runVMFunction)

	// if function name is not empty, define it in the env
	if funcExpr.Name != "" && funcExpr.Recv == "" {
		runInfo.env.DefineValue(funcExpr.Name, runInfo.rv)
	}

	return funcType
}

func (runInfo *runInfoStruct) anonCallErrExpr() {
	anonExpr := runInfo.expr.(*ast.AnonCallErrExpr)
	nExpr := &ast.AnonCallExpr{
		Expr:     anonExpr.Expr,
		SubExprs: anonExpr.SubExprs,
		VarArg:   anonExpr.VarArg,
	}
	runInfo.expr = nExpr
	runInfo.anonCallExpr()
	runInfo.handleError()
}

// anonCallExpr handles ast.AnonCallExpr which calls a function anonymously
func (runInfo *runInfoStruct) anonCallExpr() {
	anonCallExpr := runInfo.expr.(*ast.AnonCallExpr)

	runInfo.expr = anonCallExpr.Expr
	runInfo.invokeExpr()
	if runInfo.err != nil {
		return
	}

	if runInfo.rv.Kind() == reflect.Interface && !runInfo.rv.IsNil() {
		runInfo.rv = runInfo.rv.Elem()
	}
	if runInfo.rv.Kind() != reflect.Func {
		runInfo.err = newStringError(anonCallExpr, "cannot call type "+runInfo.rv.Kind().String())
		runInfo.rv = nilValue
		return
	}

	expr := &ast.CallExpr{
		Func:     runInfo.rv,
		SubExprs: anonCallExpr.SubExprs,
		VarArg:   anonCallExpr.VarArg,
		Go:       anonCallExpr.Go,
	}
	expr.SetPosition(anonCallExpr.Position())
	runInfo.expr = expr
	runInfo.invokeExpr()
	runInfo.recv = zeroValue
}

func (runInfo *runInfoStruct) callErrExpr() {
	callExpr := runInfo.expr.(*ast.CallErrExpr)
	runInfo.expr = &ast.CallExpr{
		Func:     callExpr.Func,
		Name:     callExpr.Name,
		SubExprs: callExpr.SubExprs,
		VarArg:   callExpr.VarArg,
	}
	runInfo.callExpr()
	runInfo.handleError()
}

func (runInfo *runInfoStruct) handleError() {
	if runInfo.err == nil && runInfo.callErr >= 0 && runInfo.rv.Kind() == reflect.Slice {
		rv := runInfo.rv
		idx := runInfo.callErr

		v := runInfo.rv.Index(idx)
		if !v.IsNil() {
			runInfo.stmt = &ast.ThrowStmt{
				Expr: &ast.LiteralExpr{Literal: v},
			}
			runInfo.runSingleStmt()
			return
		}

		var ns reflect.Value
		if rv.Len()-1 == 1 {
			ns = rv.Index(rv.Len() - idx - 1) // error can be the first or the second arg
		} else {
			ns = reflect.MakeSlice(rv.Type(), 0, rv.Len()-1)
			for j := 0; j < rv.Len(); j++ {
				if j == idx {
					continue
				}
				ns = reflect.Append(ns, rv.Index(j))
			}
		}
		runInfo.rv = ns
	}
}

// callExpr handles *ast.CallExpr which calls a function
func (runInfo *runInfoStruct) callExpr() {
	// Note that if the function type looks the same as the VM function type, the returned values will probably be wrong

	callExpr := runInfo.expr.(*ast.CallExpr)

	f := callExpr.Func
	if !f.IsValid() {
		// if function is not valid try to get by function name
		f, runInfo.err = runInfo.env.GetValue(callExpr.Name)
		if runInfo.err != nil {
			runInfo.err = newError(callExpr, runInfo.err)
			runInfo.rv = nilValue
			return
		}
	}

	if f.Kind() == reflect.Interface && !f.IsNil() {
		f = f.Elem()
	}
	if f.Kind() != reflect.Func {
		runInfo.err = newStringError(callExpr, "cannot call type "+f.Kind().String())
		runInfo.rv = nilValue
		return
	}

	var rvs []reflect.Value
	var args []reflect.Value
	var useCallSlice bool
	fType := f.Type()
	// check if this is a runVMFunction type
	isRunVMFunction := checkIfRunVMFunction(fType)
	// create/convert the args to the function
	args, useCallSlice = runInfo.makeCallArgs(fType, isRunVMFunction, callExpr)
	if runInfo.err != nil {
		return
	}

	if !runInfo.options.Debug {
		// captures panic
		defer recoverFunc(runInfo)
	}

	runInfo.rv = nilValue

	// useCallSlice lets us know to use CallSlice instead of Call because of the format of the args
	if useCallSlice {
		if callExpr.Go {
			go f.CallSlice(args)
			return
		}
		rvs = f.CallSlice(args)
	} else {
		if callExpr.Go {
			go f.Call(args)
			return
		}
		rvs = f.Call(args)
	}
	// virtual functions already handle errors (included in the return)
	if !isRunVMFunction {
		for i, v := range rvs {
			isErr := v.Type() == errorType
			if !isErr && v.CanInterface() {
				_, isErr = v.Interface().(error)
			}

			if isErr {
				runInfo.callErr = i
				break
			}
		}
	}

	// TOFIX: how VM pointers/addressing work
	// Until then, this is a work around to set pointers back to VM variables
	// This will probably panic for some functions and/or calls that are variadic
	if !isRunVMFunction {
		for i, expr := range callExpr.SubExprs {
			if addrExpr, ok := expr.(*ast.AddrExpr); ok {
				if identExpr, ok := addrExpr.Expr.(*ast.IdentExpr); ok {
					runInfo.rv = args[i].Elem()
					runInfo.expr = identExpr
					runInfo.invokeLetExpr()
				}
			}
		}
	}

	// processCallReturnValues to get/convert return values to normal rv form
	runInfo.rv, runInfo.err = processCallReturnValues(rvs, isRunVMFunction, true)
}

// checkIfRunVMFunction checking the number and types of the reflect.Type.
// If it matches the types for a runVMFunction this will return true, otherwise false
func checkIfRunVMFunction(rt reflect.Type) bool {
	if rt.NumIn() >= 2 && rt.In(0) == contextType && rt.In(1) == vmStructType {
		return true
	}
	if rt.NumIn() < 1 || rt.NumOut() != 2 || rt.In(0) != contextType || rt.Out(0) != reflectValueType || rt.Out(1) != reflectValueType {
		return false
	}
	if rt.NumIn() > 1 {
		if rt.IsVariadic() {
			if rt.In(rt.NumIn()-1) != interfaceSliceType {
				return false
			}
		} else {
			if rt.In(rt.NumIn()-1) != reflectValueType {
				return false
			}
		}
		for i := 1; i < rt.NumIn()-1; i++ {
			if rt.In(i) != reflectValueType {
				return false
			}
		}
	}
	return true
}

// makeCallArgs creates the arguments reflect.Value slice for the four different kinds of functions.
// Also returns true if CallSlice should be used on the arguments, or false if Call should be used.
func (runInfo *runInfoStruct) makeCallArgs(rt reflect.Type, isRunVMFunction bool, callExpr *ast.CallExpr) ([]reflect.Value, bool) {
	// number of arguments
	numInReal := rt.NumIn()
	numIn := numInReal
	hasRecv := runInfo.recv.IsValid() && numIn >= 2 && rt.In(1) == vmStructType
	if isRunVMFunction {
		// for runVMFunction the first arg is context so does not count against number of SubExprs
		numIn--
		if hasRecv {
			numIn--
		}
	}
	if hasRecv {
		if runInfo.recv.Type() != vmStructType {
			runInfo.recv = reflect.ValueOf(&vmStruct{runInfo.recv})
		}
	}

	if numIn < 1 {
		// no arguments needed
		if isRunVMFunction {
			// for runVMFunction first arg is always context
			rv := []reflect.Value{reflect.ValueOf(runInfo.ctx)}
			if hasRecv {
				rv = append(rv, runInfo.recv)
			}
			return rv, false
		}
		return []reflect.Value{}, false
	}

	// number of expressions
	numExprs := len(callExpr.SubExprs)
	// checks to short circuit wrong number of arguments
	if (!rt.IsVariadic() && !callExpr.VarArg && numIn != numExprs) ||
		(rt.IsVariadic() && callExpr.VarArg && (numIn < numExprs || numIn > numExprs+1)) ||
		(rt.IsVariadic() && !callExpr.VarArg && numIn > numExprs+1) ||
		(!rt.IsVariadic() && callExpr.VarArg && numIn < numExprs) {
		runInfo.err = newStringError(callExpr, fmt.Sprintf("function wants %v arguments but received %v", numIn, numExprs))
		runInfo.rv = nilValue
		return nil, false
	}
	if rt.IsVariadic() && rt.In(numInReal-1).Kind() != reflect.Slice && rt.In(numInReal-1).Kind() != reflect.Array {
		runInfo.err = newStringError(callExpr, "function is variadic but last parameter is of type "+rt.In(numInReal-1).String())
		runInfo.rv = nilValue
		return nil, false
	}

	var args []reflect.Value
	indexIn := 0
	indexInReal := 0
	indexExpr := 0

	if numInReal > numExprs {
		args = make([]reflect.Value, 0, numInReal)
	} else {
		args = make([]reflect.Value, 0, numExprs)
	}
	if isRunVMFunction {
		// for runVMFunction first arg is always context
		args = append(args, reflect.ValueOf(runInfo.ctx))
		if hasRecv {
			args = append(args, runInfo.recv)
			//indexInReal++
		}
		indexInReal++
	}

	// create arguments except the last one
	for indexInReal < numInReal-1 && indexExpr < numExprs-1 {
		runInfo.expr = callExpr.SubExprs[indexExpr]
		runInfo.invokeExpr()
		if runInfo.err != nil {
			return nil, false
		}
		if isRunVMFunction {
			args = append(args, reflect.ValueOf(runInfo.rv))
		} else {
			runInfo.rv, runInfo.err = convertReflectValueToType(runInfo.rv, rt.In(indexInReal))
			if runInfo.err != nil {
				runInfo.err = newStringError(callExpr.SubExprs[indexExpr],
					"function wants argument type "+rt.In(indexInReal).String()+" but received type "+runInfo.rv.Type().String())
				runInfo.rv = nilValue
				return nil, false
			}
			args = append(args, runInfo.rv)
		}
		indexIn++
		indexInReal++
		indexExpr++
	}

	if !rt.IsVariadic() && !callExpr.VarArg {
		// function is not variadic and call is not variadic
		// add last arguments and return
		runInfo.expr = callExpr.SubExprs[indexExpr]
		runInfo.invokeExpr()
		if runInfo.err != nil {
			return nil, false
		}
		if runInfo.err != nil {
			return nil, false
		}
		if isRunVMFunction {
			args = append(args, reflect.ValueOf(runInfo.rv))
		} else {
			runInfo.rv, runInfo.err = convertReflectValueToType(runInfo.rv, rt.In(indexInReal))
			if runInfo.err != nil {
				runInfo.err = newStringError(callExpr.SubExprs[indexExpr],
					"function wants argument type "+rt.In(indexInReal).String()+" but received type "+runInfo.rv.Type().String())
				runInfo.rv = nilValue
				return nil, false
			}
			args = append(args, runInfo.rv)
		}
		return args, false
	}

	if !rt.IsVariadic() && callExpr.VarArg {
		// function is not variadic and call is variadic
		runInfo.expr = callExpr.SubExprs[indexExpr]
		runInfo.invokeExpr()
		if runInfo.err != nil {
			return nil, false
		}
		if runInfo.rv.Kind() != reflect.Slice && runInfo.rv.Kind() != reflect.Array {
			runInfo.err = newStringError(callExpr, "call is variadic but last parameter is of type "+runInfo.rv.Type().String())
			runInfo.rv = nilValue
			return nil, false
		}
		if runInfo.rv.Len() < numIn-indexIn {
			runInfo.err = newStringError(callExpr, fmt.Sprintf("function wants %v arguments but received %v", numIn, numExprs+runInfo.rv.Len()-1))
			runInfo.rv = nilValue
			return nil, false
		}

		indexSlice := 0
		for indexInReal < numInReal {
			if isRunVMFunction {
				args = append(args, reflect.ValueOf(runInfo.rv.Index(indexSlice)))
			} else {
				runInfo.rv, runInfo.err = convertReflectValueToType(runInfo.rv.Index(indexSlice), rt.In(indexInReal))
				if runInfo.err != nil {
					runInfo.err = newStringError(callExpr.SubExprs[indexExpr],
						"function wants argument type "+rt.In(indexInReal).String()+" but received type "+runInfo.rv.Type().String())
					runInfo.rv = nilValue
					return nil, false
				}
				args = append(args, runInfo.rv)
			}
			indexIn++
			indexInReal++
			indexSlice++
		}
		return args, false
	}

	// function is variadic and call may or may not be variadic

	if indexExpr == numExprs {
		// no more expressions, return what we have and let reflect Call handle if call is variadic or not
		return args, false
	}

	if numIn > numExprs {
		// there are more arguments after this one, so does not matter if call is variadic or not
		// add the last argument then return what we have and let reflect Call handle if call is variadic or not
		runInfo.expr = callExpr.SubExprs[indexExpr]
		runInfo.invokeExpr()
		if runInfo.err != nil {
			return nil, false
		}
		if isRunVMFunction {
			args = append(args, reflect.ValueOf(runInfo.rv))
		} else {
			runInfo.rv, runInfo.err = convertReflectValueToType(runInfo.rv, rt.In(indexInReal))
			if runInfo.err != nil {
				runInfo.err = newStringError(callExpr.SubExprs[indexExpr],
					"function wants argument type "+rt.In(indexInReal).String()+" but received type "+runInfo.rv.Type().String())
				runInfo.rv = nilValue
				return nil, false
			}
			args = append(args, runInfo.rv)
		}
		return args, false
	}

	if rt.IsVariadic() && !callExpr.VarArg {
		// function is variadic and call is not variadic
		sliceType := rt.In(numInReal - 1).Elem()
		for indexExpr < numExprs {
			runInfo.expr = callExpr.SubExprs[indexExpr]
			runInfo.invokeExpr()
			if runInfo.err != nil {
				return nil, false
			}
			runInfo.rv, runInfo.err = convertReflectValueToType(runInfo.rv, sliceType)
			if runInfo.err != nil {
				runInfo.err = newStringError(callExpr.SubExprs[indexExpr],
					"function wants argument type "+rt.In(indexInReal).String()+" but received type "+runInfo.rv.Type().String())
				runInfo.rv = nilValue
				return nil, false
			}
			args = append(args, runInfo.rv)
			indexExpr++
		}
		return args, false

	}

	// function is variadic and call is variadic
	// the only time we return CallSlice is true
	sliceType := rt.In(numInReal - 1)
	if sliceType.Kind() == reflect.Interface && !runInfo.rv.IsNil() {
		sliceType = sliceType.Elem()
	}
	runInfo.expr = callExpr.SubExprs[indexExpr]
	runInfo.invokeExpr()
	if runInfo.err != nil {
		return nil, false
	}
	runInfo.rv, runInfo.err = convertReflectValueToType(runInfo.rv, sliceType)
	if runInfo.err != nil {
		runInfo.err = newStringError(callExpr.SubExprs[indexExpr],
			"function wants argument type "+rt.In(indexInReal).String()+" but received type "+runInfo.rv.Type().String())
		runInfo.rv = nilValue
		return nil, false
	}
	args = append(args, runInfo.rv)

	return args, true
}

// processCallReturnValues get/converts the values returned from a function call into our normal reflect.Value, error
func processCallReturnValues(rvs []reflect.Value, isRunVMFunction bool, convertToInterfaceSlice bool) (reflect.Value, error) {
	// check if it is not runVMFunction
	if !isRunVMFunction {
		// the function was a Go function, convert to our normal reflect.Value, error
		switch len(rvs) {
		case 0:
			// no return values so return nil reflect.Value and nil error
			return nilValue, nil
		case 1:
			// one return value but need to add nil error
			return rvs[0], nil
		}
		if convertToInterfaceSlice {
			// need to convert from a slice of reflect.Value to slice of interface
			return reflectValueSlicetoInterfaceSlice(rvs), nil
		}
		// need to keep as slice of reflect.Value
		return reflect.ValueOf(rvs), nil
	}

	// is a runVMFunction, expect return in the runVMFunction format
	// convertToInterfaceSlice is ignored
	// some of the below checks probably can be removed because they are done in checkIfRunVMFunction

	if len(rvs) != 2 {
		return nilValue, fmt.Errorf("VM function did not return 2 values but returned %v values", len(rvs))
	}
	if rvs[0].Type() != reflectValueType {
		return nilValue, fmt.Errorf("VM function value 1 did not return reflect value type but returned %v type", rvs[0].Type().String())
	}
	if rvs[1].Type() != reflectValueType {
		return nilValue, fmt.Errorf("VM function value 2 did not return reflect value type but returned %v type", rvs[1].Type().String())
	}

	rvError := rvs[1].Interface().(reflect.Value)
	if rvError.Type() != errorType && rvError.Type() != vmErrorType {
		return nilValue, fmt.Errorf("VM function error type is %v", rvError.Type())
	}

	if rvError.IsNil() {
		// no error, so return the normal VM reflect.Value form
		return rvs[0].Interface().(reflect.Value), nil
	}

	// VM returns two types of errors, check to see which type
	if rvError.Type() == vmErrorType {
		// convert to VM *Error
		return nilValue, rvError.Interface().(*Error)
	}
	// convert to error
	return nilValue, rvError.Interface().(error)
}