Merge pull request #121 from DDP-Projekt/transitive-assigneable-casts

bafto · web-flow · commit 874b489b7f84 · 2025-04-26T16:07:55.000+02:00
Transitive Casts als Assigneables
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -11,6 +11,7 @@ Der Changelog von DDP. Sortiert nach Release.
 
 ## In Entwicklung
 
+- [Neu] Typanpassende Ausdrücke können nun als Referenzen übergeben werden, solange sie nur Typaliase bzw. Typdefinitionen behandeln
 - [Fix] Bug im Kompilierer, bei dem VTables für primitive Typen falsch generiert wurden
 - [Fix] Bug in Duden/Listen -> Elementweise_Quotient_Kommazahl wurde in der generischen Implementation behoben
 - [Breaking] Duden/Sortierung, Duden/HashTabelle und Duden/Listen verwenden nun generische Funktionen und Kombinationen
diff --git a/src/ast/annotators/const_func_param.go b/src/ast/annotators/const_func_param.go
@@ -148,6 +148,8 @@ func doesReferenceVarMutable(expr ast.Expression, decls []*ast.VarDecl) []*ast.V
 		return doesReferenceVarMutable(ass.Lhs, decls)
 	case *ast.FieldAccess:
 		return doesReferenceVarMutable(ass.Rhs, decls)
+	case *ast.CastAssigneable:
+		return doesReferenceVarMutable(ass.Lhs, decls)
 	default:
 		return decls // better safe than sorry
 	}
diff --git a/src/ast/expressions.go b/src/ast/expressions.go
diff --git a/src/ast/helper_visitor.go b/src/ast/helper_visitor.go
@@ -352,6 +352,14 @@ func (h *helperVisitor) VisitCastExpr(expr *CastExpr) VisitResult {
 	return h.visitChildren(result, expr.Lhs)
 }
 
+func (h *helperVisitor) VisitCastAssigneable(expr *CastAssigneable) VisitResult {
+	result := VisitRecurse
+	if vis, ok := h.actualVisitor.(CastAssigneableVisitor); ok {
+		result = vis.VisitCastAssigneable(expr)
+	}
+	return h.visitChildren(result, expr.Lhs)
+}
+
 func (h *helperVisitor) VisitTypeOpExpr(expr *TypeOpExpr) VisitResult {
 	result := VisitRecurse
 	if vis, ok := h.actualVisitor.(TypeOpExprVisitor); ok {
diff --git a/src/ast/printer.go b/src/ast/printer.go
@@ -235,6 +235,11 @@ func (pr *printer) VisitCastExpr(expr *CastExpr) VisitResult {
 	return VisitRecurse
 }
 
+func (pr *printer) VisitCastAssigneable(expr *CastAssigneable) VisitResult {
+	pr.parenthesizeNode(fmt.Sprintf("CastAssigneable[%s]", expr.TargetType), expr.Lhs)
+	return VisitRecurse
+}
+
 func (pr *printer) VisitTypeOpExpr(expr *TypeOpExpr) VisitResult {
 	pr.parenthesizeNode(fmt.Sprintf("TypeOpExpr[%s]: %s", expr.Operator, expr.Rhs))
 	return VisitRecurse
diff --git a/src/ast/visitor.go b/src/ast/visitor.go
@@ -51,6 +51,7 @@ type FullVisitor interface {
 	BinaryExprVisitor
 	TernaryExprVisitor
 	CastExprVisitor
+	CastAssigneableVisitor
 	TypeOpExprVisitor
 	TypeCheckVisitor
 	GroupingVisitor
@@ -166,6 +167,10 @@ type (
 		Visitor
 		VisitCastExpr(*CastExpr) VisitResult
 	}
+	CastAssigneableVisitor interface {
+		Visitor
+		VisitCastAssigneable(*CastAssigneable) VisitResult
+	}
 	TypeOpExprVisitor interface {
 		Visitor
 		VisitTypeOpExpr(*TypeOpExpr) VisitResult
@@ -442,6 +447,15 @@ func (f CastExprVisitorFunc) VisitCastExpr(expr *CastExpr) VisitResult {
 	return f(expr)
 }
 
+type CastAssigneableVisitorFunc func(*CastAssigneable) VisitResult
+
+var _ CastAssigneableVisitor = (CastAssigneableVisitorFunc)(nil)
+
+func (CastAssigneableVisitorFunc) Visitor() {}
+func (f CastAssigneableVisitorFunc) VisitCastAssigneable(expr *CastAssigneable) VisitResult {
+	return f(expr)
+}
+
 type TypeOpExprVisitorFunc func(*TypeOpExpr) VisitResult
 
 var _ TypeOpExprVisitor = (TypeOpExprVisitorFunc)(nil)
diff --git a/src/compiler/compiler.go b/src/compiler/compiler.go
@@ -1795,6 +1795,11 @@ func (c *compiler) VisitCastExpr(e *ast.CastExpr) ast.VisitResult {
 	return ast.VisitRecurse
 }
 
+func (c *compiler) VisitCastAssigneable(e *ast.CastAssigneable) ast.VisitResult {
+	c.evaluate(&ast.CastExpr{Lhs: e.Lhs, TargetType: e.TargetType, Range: e.Range})
+	return ast.VisitRecurse
+}
+
 func (c *compiler) VisitTypeOpExpr(e *ast.TypeOpExpr) ast.VisitResult {
 	switch e.Operator {
 	case ast.TYPE_SIZE:
@@ -1879,6 +1884,8 @@ func (c *compiler) evaluateAssignableOrReference(ass ast.Assigneable, as_ref boo
 		} else {
 			c.err("non-struct type passed to FieldAccess")
 		}
+	case *ast.CastAssigneable:
+		return c.evaluateAssignableOrReference(assign.Lhs, as_ref)
 	}
 	c.err("Invalid types in evaluateAssignableOrReference %s", ass)
 	return nil, nil, nil
diff --git a/src/parser/expressions.go b/src/parser/expressions.go
@@ -781,6 +781,17 @@ func (p *parser) assigneable() ast.Assigneable {
 		}
 		var ass ast.Assigneable = ident
 
+		for p.matchAny(token.ALS) {
+			ass = &ast.CastAssigneable{
+				Range: token.Range{
+					Start: ass.GetRange().Start,
+					End:   token.NewEndPos(p.previous()),
+				},
+				TargetType: p.parseType(false),
+				Lhs:        ass,
+			}
+		}
+
 		for p.matchAny(token.VON) {
 			if p.matchAny(token.IDENTIFIER) {
 				rhs := assigneable_impl(true)
@@ -801,7 +812,7 @@ func (p *parser) assigneable() ast.Assigneable {
 		if !isInFieldAcess {
 			for p.matchAny(token.AN) {
 				p.consumeSeq(token.DER, token.STELLE)
-				index := p.unary() // TODO: check if this can stay p.expression or if p.unary is better
+				index := p.unary()
 				ass = &ast.Indexing{
 					Lhs:   ass,
 					Index: index,
diff --git a/src/parser/resolver/resolver.go b/src/parser/resolver/resolver.go
@@ -285,6 +285,11 @@ func (r *Resolver) VisitCastExpr(expr *ast.CastExpr) ast.VisitResult {
 	return ast.VisitRecurse
 }
 
+func (r *Resolver) VisitCastAssigneable(expr *ast.CastAssigneable) ast.VisitResult {
+	r.visit(expr.Lhs) // visit the actual expressions
+	return ast.VisitRecurse
+}
+
 func (r *Resolver) VisitTypeOpExpr(expr *ast.TypeOpExpr) ast.VisitResult {
 	return ast.VisitRecurse
 }
@@ -372,6 +377,8 @@ func (r *Resolver) VisitAssignStmt(stmt *ast.AssignStmt) ast.VisitResult {
 		r.visit(assign.Index)
 	case *ast.FieldAccess:
 		r.visit(assign.Rhs)
+	case *ast.CastAssigneable:
+		r.visit(assign.Lhs)
 	}
 	r.visit(stmt.Rhs)
 	return ast.VisitRecurse
diff --git a/src/parser/typechecker/assignable_checker.go b/src/parser/typechecker/assignable_checker.go
@@ -16,12 +16,24 @@ func isAssignable(expr ast.Expression) (ast.Assigneable, bool) {
 		return isAssignable(ass.Expr)
 	case *ast.BinaryExpr:
 		return isBinaryExprAssignable(ass)
+	case *ast.CastExpr:
+		// overloaded expressions cannot be assignables
+		if ass.OverloadedBy != nil {
+			return nil, false
+		}
+
+		return isAssignable(ass.Lhs)
 	default:
 		return nil, false
 	}
 }
 
 func isBinaryExprAssignable(expr *ast.BinaryExpr) (ast.Assigneable, bool) {
+	// overloaded expressions cannot be assignables
+	if expr.OverloadedBy != nil {
+		return nil, false
+	}
+
 	switch expr.Operator {
 	case ast.BIN_FIELD_ACCESS:
 		ident, isIdent := expr.Lhs.(*ast.Ident)
@@ -44,8 +56,6 @@ func isBinaryExprAssignable(expr *ast.BinaryExpr) (ast.Assigneable, bool) {
 				Index: expr.Rhs,
 			}, true
 		}
-	default:
-		return nil, false
 	}
 	return nil, false
 }
diff --git a/src/parser/typechecker/assignable_checker_test.go b/src/parser/typechecker/assignable_checker_test.go
@@ -26,4 +26,33 @@ func TestIsAssignable(t *testing.T) {
 		Rhs:      &ast.Ident{},
 	}})
 	assert.True(ok)
+
+	_, ok = isAssignable(&ast.Grouping{Expr: &ast.BinaryExpr{
+		Lhs:      &ast.Ident{},
+		Operator: ast.BIN_FIELD_ACCESS,
+		Rhs:      &ast.CastExpr{Lhs: &ast.Ident{}},
+	}})
+	assert.True(ok)
+
+	_, ok = isAssignable(&ast.Grouping{Expr: &ast.BinaryExpr{
+		Lhs:      &ast.Ident{},
+		Operator: ast.BIN_FIELD_ACCESS,
+		Rhs:      &ast.CastExpr{Lhs: &ast.IntLit{}},
+	}})
+	assert.False(ok)
+
+	_, ok = isAssignable(&ast.BinaryExpr{
+		Lhs:          &ast.Ident{},
+		Operator:     ast.BIN_FIELD_ACCESS,
+		Rhs:          &ast.Ident{},
+		OverloadedBy: &ast.OperatorOverload{},
+	})
+	assert.False(ok)
+
+	_, ok = isAssignable(&ast.Grouping{Expr: &ast.BinaryExpr{
+		Lhs:      &ast.Ident{},
+		Operator: ast.BIN_FIELD_ACCESS,
+		Rhs:      &ast.CastExpr{Lhs: &ast.Ident{}, OverloadedBy: &ast.OperatorOverload{}},
+	}})
+	assert.False(ok)
 }
diff --git a/src/parser/typechecker/typechecker.go b/src/parser/typechecker/typechecker.go
@@ -566,6 +566,15 @@ func (t *Typechecker) VisitCastExpr(expr *ast.CastExpr) ast.VisitResult {
 	return ast.VisitRecurse
 }
 
+func (t *Typechecker) VisitCastAssigneable(expr *ast.CastAssigneable) ast.VisitResult {
+	lhs := t.Evaluate(expr.Lhs)
+	if !ddptypes.Equal(ddptypes.TrueUnderlying(lhs), ddptypes.TrueUnderlying(expr.TargetType)) {
+		t.err(ddperror.TYP_BAD_CAST, expr.GetRange(), "Falsche Nutzung einer Typumwandlung in einem Referenz Kontext")
+	}
+	t.latestReturnedType = expr.TargetType
+	return ast.VisitRecurse
+}
+
 func (t *Typechecker) VisitTypeOpExpr(expr *ast.TypeOpExpr) ast.VisitResult {
 	switch expr.Operator {
 	case ast.TYPE_SIZE:
diff --git a/tests/testdata/kddp/assigneable_casts/assigneable_casts.ddp b/tests/testdata/kddp/assigneable_casts/assigneable_casts.ddp
@@ -0,0 +1,69 @@
+Binde "Duden/Ausgabe" ein.
+
+Wir definieren eine Hausnummer als eine Zahl.
+Wir definieren eine Buchstabenfolge als einen Text.
+
+Die Zahl zahl1 ist 1.
+Speichere 2 in zahl1 als Zahl.
+Schreibe zahl1 auf eine Zeile.
+
+Die Hausnummer hausnummer1 ist 1 als Hausnummer.
+[ 
+Sollte eigentlich
+	Speichere 2 als Hausnummer in hausnummer1.
+sein, aber für diesen Test nun mal so.
+]
+Speichere 2 in hausnummer1 als Zahl.
+Schreibe (hausnummer1 als Zahl) auf eine Zeile.
+
+Die Funktion foo mit dem Parameter z vom Typ Zahlen Referenz, gibt nichts zurück, macht:
+	Speichere 42 in z.
+Und kann so benutzt werden:
+	"foo <z>"
+
+Die Zahl z ist 1.
+foo (z als Zahl).
+Schreibe z auf eine Zeile.
+
+
+Die Hausnummer h ist 1 als Hausnummer.
+foo (h als Zahl).
+Schreibe (h als Zahl) auf eine Zeile.
+
+Die Funktion bar mit den Parametern z und w vom Typ Zahlen Referenz und Zahl, gibt eine Zahl zurück, macht:
+	Speichere w in z.
+	Gib z zurück.
+Und überlädt den "an der Stelle" Operator.
+
+Schreibe (z an der Stelle 5) auf eine Zeile.
+Schreibe z auf eine Zeile.
+
+Schreibe (h als Zahl an der Stelle 5) auf eine Zeile.
+Schreibe (h als Zahl) auf eine Zeile.
+
+
+[ selber test aber mit einem heap-allokierten Typ ]
+
+Die Funktion foo2 mit dem Parameter z vom Typ Text Referenz, gibt nichts zurück, macht:
+	Speichere "tschüss" in z.
+Und kann so benutzt werden:
+	"foo2 <z>"
+
+Der Text t ist "hallo".
+foo2 (t als Text).
+Schreibe t auf eine Zeile.
+
+Die Buchstabenfolge b ist "hallo" als Buchstabenfolge.
+foo2 (b als Text).
+Schreibe (b als Text) auf eine Zeile.
+
+Die Funktion bar2 mit den Parametern z und w vom Typ Text Referenz und Text, gibt einen Text zurück, macht:
+	Speichere w in z.
+	Gib z zurück.
+Und überlädt den "an der Stelle" Operator.
+
+Schreibe (t an der Stelle "test") auf eine Zeile.
+Schreibe t auf eine Zeile.
+
+Schreibe (b als Text an der Stelle "test") auf eine Zeile.
+Schreibe (b als Text) auf eine Zeile.
diff --git a/tests/testdata/kddp/assigneable_casts/expected.txt b/tests/testdata/kddp/assigneable_casts/expected.txt
@@ -0,0 +1,14 @@
+2
+2
+42
+42
+5
+5
+5
+5
+tschüss
+tschüss
+test
+test
+test
+test

Original file line number	Diff line number	Diff line change
`@@ -148,6 +148,8 @@ func doesReferenceVarMutable(expr ast.Expression, decls []ast.VarDecl) []ast.V`
`148`	`148`	`return doesReferenceVarMutable(ass.Lhs, decls)`
`149`	`149`	`case *ast.FieldAccess:`
`150`	`150`	`return doesReferenceVarMutable(ass.Rhs, decls)`
	`151`	`+ case *ast.CastAssigneable:`
	`152`	`+ return doesReferenceVarMutable(ass.Lhs, decls)`
`151`	`153`	`default:`
`152`	`154`	`return decls // better safe than sorry`
`153`	`155`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1795,6 +1795,11 @@ func (c compiler) VisitCastExpr(e ast.CastExpr) ast.VisitResult {`
`1795`	`1795`	`return ast.VisitRecurse`
`1796`	`1796`	`}`
`1797`	`1797`
	`1798`	`+func (c compiler) VisitCastAssigneable(e ast.CastAssigneable) ast.VisitResult {`
	`1799`	`+ c.evaluate(&ast.CastExpr{Lhs: e.Lhs, TargetType: e.TargetType, Range: e.Range})`
	`1800`	`+ return ast.VisitRecurse`
	`1801`	`+}`
	`1802`	`+`
`1798`	`1803`	`func (c compiler) VisitTypeOpExpr(e ast.TypeOpExpr) ast.VisitResult {`
`1799`	`1804`	`switch e.Operator {`
`1800`	`1805`	`case ast.TYPE_SIZE:`
`@@ -1879,6 +1884,8 @@ func (c *compiler) evaluateAssignableOrReference(ass ast.Assigneable, as_ref boo`
`1879`	`1884`	`} else {`
`1880`	`1885`	`c.err("non-struct type passed to FieldAccess")`
`1881`	`1886`	`}`
	`1887`	`+ case *ast.CastAssigneable:`
	`1888`	`+ return c.evaluateAssignableOrReference(assign.Lhs, as_ref)`
`1882`	`1889`	`}`
`1883`	`1890`	`c.err("Invalid types in evaluateAssignableOrReference %s", ass)`
`1884`	`1891`	`return nil, nil, nil`
Original file line number	Diff line number	Diff line change
`@@ -285,6 +285,11 @@ func (r Resolver) VisitCastExpr(expr ast.CastExpr) ast.VisitResult {`
`285`	`285`	`return ast.VisitRecurse`
`286`	`286`	`}`
`287`	`287`
	`288`	`+func (r Resolver) VisitCastAssigneable(expr ast.CastAssigneable) ast.VisitResult {`
	`289`	`+ r.visit(expr.Lhs) // visit the actual expressions`
	`290`	`+ return ast.VisitRecurse`
	`291`	`+}`
	`292`	`+`
`288`	`293`	`func (r Resolver) VisitTypeOpExpr(expr ast.TypeOpExpr) ast.VisitResult {`
`289`	`294`	`return ast.VisitRecurse`
`290`	`295`	`}`
`@@ -372,6 +377,8 @@ func (r Resolver) VisitAssignStmt(stmt ast.AssignStmt) ast.VisitResult {`
`372`	`377`	`r.visit(assign.Index)`
`373`	`378`	`case *ast.FieldAccess:`
`374`	`379`	`r.visit(assign.Rhs)`
	`380`	`+ case *ast.CastAssigneable:`
	`381`	`+ r.visit(assign.Lhs)`
`375`	`382`	`}`
`376`	`383`	`r.visit(stmt.Rhs)`
`377`	`384`	`return ast.VisitRecurse`