Allow passing structs as pointers to functions (#63)

monstermichl · monstermichl · commit 240ee115cfcb · 2025-09-20T23:29:19.000+02:00
diff --git a/parser/function.go b/parser/function.go
@@ -3,7 +3,7 @@ package parser
 type FunctionDefinition struct {
 	name        string
 	returnTypes []ValueType
-	params      []Variable
+	params      []Param
 	body        []Statement
 	public      bool
 }
@@ -28,7 +28,7 @@ func (e FunctionDefinition) ReturnTypes() []ValueType {
 	return e.returnTypes
 }
 
-func (e FunctionDefinition) Params() []Variable {
+func (e FunctionDefinition) Params() []Param {
 	return e.params
 }
 
@@ -43,7 +43,7 @@ func (e FunctionDefinition) Public() bool {
 type FunctionCall struct {
 	name        string
 	returnTypes []ValueType
-	params      []Variable
+	params      []Param
 	arguments   []Expression
 }
 
@@ -67,7 +67,7 @@ func (e FunctionCall) ReturnTypes() []ValueType {
 	return e.returnTypes
 }
 
-func (e FunctionCall) Params() []Variable {
+func (e FunctionCall) Params() []Param {
 	return e.params
 }
 
diff --git a/parser/param.go b/parser/param.go
@@ -0,0 +1,22 @@
+package parser
+
+type Param struct {
+	Variable
+	pointer bool
+}
+
+func NewParam(name string, valueType ValueType, layer int, public bool, pointer bool) Param {
+	return Param{
+		Variable: Variable{
+			name,
+			valueType,
+			layer,
+			public,
+		},
+		pointer: pointer,
+	}
+}
+
+func (p Param) Pointer() bool {
+	return p.pointer
+}
diff --git a/parser/parser.go b/parser/parser.go
@@ -1862,8 +1862,8 @@ func (p *Parser) evaluateVarAssignment(importAlias string, ctx context) (Stateme
 	}, nil
 }
 
-func (p *Parser) evaluateParams(ctx context) ([]Variable, error) {
-	params := []Variable{}
+func (p *Parser) evaluateParams(ctx context) ([]Param, error) {
+	params := []Param{}
 
 	for {
 		nameToken := p.peek()
@@ -1884,10 +1884,25 @@ func (p *Parser) evaluateParams(ctx context) ([]Variable, error) {
 		if exists {
 			return params, fmt.Errorf("scope already contains a variable with the name %s", name)
 		}
+		pointer := false
+		pointerToken := p.peek()
+
+		if pointerToken.Type() == lexer.BINARY_OPERATOR {
+			p.eat()
+			pointerValue := pointerToken.Value()
+
+			if pointerValue != "*" {
+				return nil, p.expectedError(fmt.Sprintf(`"*" but got "%s"`, pointerValue), pointerToken)
+			}
+			pointer = true
+		}
+		valueTypeToken := p.peek()
 		valueType, err := p.evaluateValueType(ctx)
 
 		if err != nil {
 			return nil, err
+		} else if pointer && valueType.Type().Kind() != TypeKindStruct {
+			return nil, p.atError(fmt.Sprintf("pointers are only supported for structs but got %s", valueType.String()), valueTypeToken)
 		}
 		nextToken := p.peek()
 		nextTokenType := nextToken.Type()
@@ -1897,7 +1912,7 @@ func (p *Parser) evaluateParams(ctx context) ([]Variable, error) {
 		} else if nextTokenType == lexer.COMMA {
 			p.eat()
 		}
-		params = append(params, NewVariable(name, valueType, ctx.layer+1, false))
+		params = append(params, NewParam(name, valueType, ctx.layer+1, false, pointer))
 	}
 	return params, nil
 }
@@ -1925,7 +1940,7 @@ func (p *Parser) evaluateFunctionDefinition(ctx context) (Statement, error) {
 		return nil, p.expectedError("unique function name", nameToken)
 	}
 	openingBrace := p.peek()
-	params := []Variable{}
+	params := []Param{}
 
 	// Clone context to avoid modification of the original.
 	ctx = ctx.clone()
@@ -2704,8 +2719,16 @@ func (p *Parser) evaluateNamedValueEvaluation(importAlias string, ctx context) (
 			Const: namedValue.(Const),
 		}, nil
 	}
+	param, isParam := namedValue.(Param)
+	var variable Variable
+
+	if isParam {
+		variable = NewVariable(param.Name(), param.ValueType(), param.Layer(), param.Public())
+	} else {
+		variable = namedValue.(Variable)
+	}
 	return VariableEvaluation{
-		Variable: namedValue.(Variable),
+		Variable: variable,
 	}, nil
 }
 
@@ -3155,7 +3178,7 @@ func (p *Parser) evaluateLogicalOperation(ctx context, operator LogicalOperator,
 	return leftExpression, nil
 }
 
-func (p *Parser) evaluateArguments(typeName string, name string, params []Variable, ctx context) ([]Expression, error) {
+func (p *Parser) evaluateArguments(typeName string, name string, params []Param, ctx context) ([]Expression, error) {
 	var err error
 	openingBraceToken := p.eat()
 
diff --git a/tests/functions.go b/tests/functions.go
@@ -86,6 +86,44 @@ func testSliceParamFunctionSuccess(t *testing.T, transpilerFunc transpilerFunc)
 	})
 }
 
+func testStructParamFunctionSuccess(t *testing.T, transpilerFunc transpilerFunc) {
+	transpilerFunc(t, `
+		type easyStruct struct {
+			a string
+		}
+
+		func test(s easyStruct) {
+			s.a = "Bye"
+		}
+		s := easyStruct{a: "Hello"}
+		print(s.a)
+		test(s)
+		print(s.a)
+	`, func(output string, err error) {
+		require.Nil(t, err)
+		require.Equal(t, "Hello\nHello", output)
+	})
+}
+
+func testStructPointerParamFunctionSuccess(t *testing.T, transpilerFunc transpilerFunc) {
+	transpilerFunc(t, `
+		type easyStruct struct {
+			a string
+		}
+
+		func test(s *easyStruct) {
+			s.a = "Bye"
+		}
+		s := easyStruct{a: "Hello"}
+		print(s.a)
+		test(s)
+		print(s.a)
+	`, func(output string, err error) {
+		require.Nil(t, err)
+		require.Equal(t, "Hello\nBye", output)
+	})
+}
+
 func testCallFunctionFromFunctionSuccess(t *testing.T, transpilerFunc transpilerFunc) {
 	transpilerFunc(t, `
 		func test1(retVal1 int, retVal2 int) (int, int) {
diff --git a/tests/functions_linux_test.go b/tests/functions_linux_test.go
@@ -28,6 +28,14 @@ func TestSliceParamFunctionSuccess(t *testing.T) {
 	testSliceParamFunctionSuccess(t, transpileBash)
 }
 
+func TestStructParamFunctionSuccess(t *testing.T) {
+	testStructParamFunctionSuccess(t, transpileBash)
+}
+
+func TestStructPointerParamFunctionSuccess(t *testing.T) {
+	testStructPointerParamFunctionSuccess(t, transpileBash)
+}
+
 func TestCallFunctionFromFunctionSuccess(t *testing.T) {
 	testCallFunctionFromFunctionSuccess(t, transpileBash)
 }
diff --git a/tests/functions_windows_test.go b/tests/functions_windows_test.go
@@ -28,6 +28,14 @@ func TestSliceParamFunctionSuccess(t *testing.T) {
 	testSliceParamFunctionSuccess(t, transpileBatch)
 }
 
+func TestStructParamFunctionSuccess(t *testing.T) {
+	testStructParamFunctionSuccess(t, transpileBatch)
+}
+
+func TestStructPointerParamFunctionSuccess(t *testing.T) {
+	testStructPointerParamFunctionSuccess(t, transpileBatch)
+}
+
 func TestCallFunctionFromFunctionSuccess(t *testing.T) {
 	testCallFunctionFromFunctionSuccess(t, transpileBatch)
 }
diff --git a/transpiler/transpiler.go b/transpiler/transpiler.go
@@ -396,7 +396,7 @@ func (t *transpiler) evaluateFor(forStatement parser.For) error {
 	return conv.ForEnd()
 }
 
-func (t *transpiler) evaluateExpressionAssignment(assignedExpression parser.Expression) (expressionResult, error) {
+func (t *transpiler) evaluateExpressionAssignment(assignedExpression parser.Expression, pointer bool) (expressionResult, error) {
 	result, err := t.evaluateExpression(assignedExpression, true)
 	value := result.firstValue()
 
@@ -408,32 +408,35 @@ func (t *transpiler) evaluateExpressionAssignment(assignedExpression parser.Expr
 	if !valueType.IsSlice() {
 		switch evaluationType := valueType.Type().(type) {
 		case parser.StructDefinition:
-			newStruct, err := t.converter.StructInitialization([]StructValue{}, true)
+			// Copy struct if it shall not be passed by reference.
+			if !pointer {
+				newStruct, err := t.converter.StructInitialization([]StructValue{}, true)
 
-			if err != nil {
-				return expressionResult{}, err
-			}
+				if err != nil {
+					return expressionResult{}, err
+				}
 
-			// If expression is a struct, the values need to be copied to avoid manipulation of the original.
-			for _, field := range evaluationType.Fields() {
-				fieldName := field.Name()
-				fieldValue, err := t.converter.StructEvaluation(value, fieldName, true)
+				// If expression is a struct, the values need to be copied to avoid manipulation of the original.
+				for _, field := range evaluationType.Fields() {
+					fieldName := field.Name()
+					fieldValue, err := t.converter.StructEvaluation(value, fieldName, true)
 
-				if err != nil {
-					return expressionResult{}, nil
+					if err != nil {
+						return expressionResult{}, nil
+					}
+					err = t.converter.StructAssignment(newStruct, fieldName, fieldValue, false)
+
+					if err != nil {
+						return expressionResult{}, err
+					}
 				}
-				err = t.converter.StructAssignment(newStruct, fieldName, fieldValue, false)
+				evaluatedValue, err := t.converter.VarEvaluation(newStruct, true, false)
 
 				if err != nil {
 					return expressionResult{}, err
 				}
+				value = evaluatedValue
 			}
-			evaluatedValue, err := t.converter.VarEvaluation(newStruct, true, false)
-
-			if err != nil {
-				return expressionResult{}, err
-			}
-			value = evaluatedValue
 		}
 	}
 	return newExpressionResult(value), nil
@@ -462,7 +465,7 @@ func (t *transpiler) evaluateConstDefinition(definition parser.ConstDefinition)
 
 func (t *transpiler) evaluateVarDefinition(definition parser.VariableDefinitionValueAssignment) error {
 	for i, variable := range definition.Variables() {
-		result, err := t.evaluateExpressionAssignment(definition.Values()[i])
+		result, err := t.evaluateExpressionAssignment(definition.Values()[i], false)
 
 		if err != nil {
 			return err
@@ -503,7 +506,7 @@ func (t *transpiler) evaluateVarDefinitionCallAssignment(definition parser.Varia
 
 func (t *transpiler) evaluateVarAssignment(assignment parser.VariableAssignmentValueAssignment) error {
 	for i, variable := range assignment.Variables() {
-		result, err := t.evaluateExpressionAssignment(assignment.Values()[i])
+		result, err := t.evaluateExpressionAssignment(assignment.Values()[i], false)
 
 		if err != nil {
 			return err
@@ -554,7 +557,7 @@ func (t *transpiler) evaluateSliceAssignment(assignment parser.SliceAssignment)
 		return err
 	}
 	assignmentValue := assignment.Assignment()
-	result, err := t.evaluateExpressionAssignment(assignmentValue)
+	result, err := t.evaluateExpressionAssignment(assignmentValue, false)
 
 	if err != nil {
 		return err
@@ -575,8 +578,8 @@ func (t *transpiler) evaluateStructAssignment(assignment parser.StructAssignment
 		return err
 	}
 	fieldAssignment := assignment.Assignment()
-	valueResult, err := t.evaluateExpressionAssignment(fieldAssignment.Value())
-	
+	valueResult, err := t.evaluateExpressionAssignment(fieldAssignment.Value(), false)
+
 	if err != nil {
 		return err
 	}
@@ -725,9 +728,10 @@ func (t *transpiler) evaluateFunctionDefinition(functionDefinition parser.Functi
 func (t *transpiler) evaluateFunctionCall(functionCall parser.FunctionCall, valueUsed bool) (expressionResult, error) {
 	name := functionCall.Name()
 	args := []string{}
+	params := functionCall.Params()
 
-	for _, arg := range functionCall.Args() {
-		result, err := t.evaluateExpressionAssignment(arg)
+	for i, arg := range functionCall.Args() {
+		result, err := t.evaluateExpressionAssignment(arg, params[i].Pointer())
 
 		if err != nil {
 			return expressionResult{}, err
@@ -783,7 +787,7 @@ func (t *transpiler) evaluateSliceInstantiation(instantiation parser.SliceInstan
 	values := []string{}
 
 	for _, expr := range instantiation.Values() {
-		result, err := t.evaluateExpressionAssignment(expr)
+		result, err := t.evaluateExpressionAssignment(expr, false)
 
 		if err != nil {
 			return expressionResult{}, err
@@ -802,7 +806,7 @@ func (t *transpiler) evaluateStructInitialization(definition parser.StructInitia
 	values := []StructValue{}
 
 	for _, value := range definition.Values() {
-		result, err := t.evaluateExpressionAssignment(value.Value())
+		result, err := t.evaluateExpressionAssignment(value.Value(), false)
 
 		if err != nil {
 			return expressionResult{}, err

Original file line number	Diff line number	Diff line change
`@@ -3,7 +3,7 @@ package parser`
`3`	`3`	`type FunctionDefinition struct {`
`4`	`4`	`name string`
`5`	`5`	`returnTypes []ValueType`
`6`		`- params []Variable`
	`6`	`+ params []Param`
`7`	`7`	`body []Statement`
`8`	`8`	`public bool`
`9`	`9`	`}`
`@@ -28,7 +28,7 @@ func (e FunctionDefinition) ReturnTypes() []ValueType {`
`28`	`28`	`return e.returnTypes`
`29`	`29`	`}`
`30`	`30`
`31`		`-func (e FunctionDefinition) Params() []Variable {`
	`31`	`+func (e FunctionDefinition) Params() []Param {`
`32`	`32`	`return e.params`
`33`	`33`	`}`
`34`	`34`
`@@ -43,7 +43,7 @@ func (e FunctionDefinition) Public() bool {`
`43`	`43`	`type FunctionCall struct {`
`44`	`44`	`name string`
`45`	`45`	`returnTypes []ValueType`
`46`		`- params []Variable`
	`46`	`+ params []Param`
`47`	`47`	`arguments []Expression`
`48`	`48`	`}`
`49`	`49`
`@@ -67,7 +67,7 @@ func (e FunctionCall) ReturnTypes() []ValueType {`
`67`	`67`	`return e.returnTypes`
`68`	`68`	`}`
`69`	`69`
`70`		`-func (e FunctionCall) Params() []Variable {`
	`70`	`+func (e FunctionCall) Params() []Param {`
`71`	`71`	`return e.params`
`72`	`72`	`}`
`73`	`73`
Original file line number	Diff line number	Diff line change
`@@ -28,6 +28,14 @@ func TestSliceParamFunctionSuccess(t *testing.T) {`
`28`	`28`	`testSliceParamFunctionSuccess(t, transpileBash)`
`29`	`29`	`}`
`30`	`30`
	`31`	`+func TestStructParamFunctionSuccess(t *testing.T) {`
	`32`	`+ testStructParamFunctionSuccess(t, transpileBash)`
	`33`	`+}`
	`34`	`+`
	`35`	`+func TestStructPointerParamFunctionSuccess(t *testing.T) {`
	`36`	`+ testStructPointerParamFunctionSuccess(t, transpileBash)`
	`37`	`+}`
	`38`	`+`
`31`	`39`	`func TestCallFunctionFromFunctionSuccess(t *testing.T) {`
`32`	`40`	`testCallFunctionFromFunctionSuccess(t, transpileBash)`
`33`	`41`	`}`