Use pointer parameter for name-binding.

The change prevents unintended ignored return value,
and also update the return value to return error instead.

Author: nickng

bind.go

@@ -3,85 +3,84 @@ package asyncpi
 // Binding.
 // This file contains functions for name binding.
 
-import (
-	"log"
-)
-
 // Bind takes a parsed process p and returned a process with valid binding.
-func Bind(p Process) Process {
-	return bind(p, []Name{})
+func Bind(p *Process) error {
+	var err error
+	*p, err = bind(*p, []Name{})
+	if err != nil {
+		return err
+	}
+	return nil
 }
 
-func bind(p Process, boundNames []Name) Process {
-	switch proc := p.(type) {
+// bind is a depth-first recursive traversal of a Process p
+// with boundNames to bind Names with the same Ident.
+func bind(p Process, boundNames []Name) (_ Process, err error) {
+	switch p := p.(type) {
 	case *NilProcess:
-		return proc
+		return p, nil
 	case *Repeat:
-		proc.Proc = bind(proc.Proc, boundNames)
-		return proc
+		p.Proc, err = bind(p.Proc, boundNames)
+		return p, err
 	case *Par:
-		for i := range proc.Procs {
-			bind(proc.Procs[i], boundNames)
+		for i := range p.Procs {
+			p.Procs[i], err = bind(p.Procs[i], boundNames)
 		}
-		return proc
+		return p, err
 	case *Recv:
 		names := make([]Name, len(boundNames))
 		for i := range boundNames {
 			names[i] = boundNames[i]
 		}
-		names = append(names, proc.Vars...)
-		for _, v := range proc.Vars {
-			for j := 0; j < len(names)-len(proc.Vars); j++ {
+		names = append(names, p.Vars...)
+		for _, v := range p.Vars {
+			for j := 0; j < len(names)-len(p.Vars); j++ {
 				if IsSameName(v, names[j]) {
-					log.Println("Warning: rebinding name", v.Ident(), "in recv")
+					// Rebinding existing bound name.
 					names = append(names[:j], names[j+1:]...)
 				}
 			}
 		}
 		var chanBound bool
 		for i, bn := range names {
-			if IsSameName(proc.Chan, bn) { // Found bound Chan
-				proc.Chan = names[i]
+			if IsSameName(p.Chan, bn) { // Found bound Chan
+				p.Chan = names[i]
 				chanBound = true
 			}
 		}
 		if !chanBound {
-			names = append(names, proc.Chan)
+			names = append(names, p.Chan)
 		}
-		proc.Cont = bind(proc.Cont, names)
-		return proc
+		p.Cont, err = bind(p.Cont, names)
+		return p, err
 	case *Send:
 		count := 0
 		for i, bn := range boundNames {
-			for j, v := range proc.Vals {
+			for j, v := range p.Vals {
 				if IsSameName(v, bn) { // Found bound name.
-					proc.Vals[j] = boundNames[i]
+					p.Vals[j] = boundNames[i]
 					count++
 				}
 			}
 		}
 		for i, bn := range boundNames {
-			if IsSameName(proc.Chan, bn) { // Found bound Chan.
-				proc.Chan = boundNames[i]
+			if IsSameName(p.Chan, bn) { // Found bound Chan.
+				p.Chan = boundNames[i]
 				count++
 			}
 		}
-		if count < len(proc.Vals)+1 {
-			log.Println("Warning:", len(proc.Vals)+1-count, "names are left unbound")
-		}
-		return proc
+		return p, err
 	case *Restrict:
-		names := append(boundNames, proc.Name)
+		names := append(boundNames, p.Name)
 		for i := 0; i < len(names)-1; i++ {
-			if IsSameName(proc.Name, names[i]) {
-				log.Println("Warning: rebinding name", proc.Name.Ident(), "in restrict")
+			if IsSameName(p.Name, names[i]) {
+				// Rebinding existing bound name.
 				names = append(names[:i], names[i+1:]...)
 			}
 		}
-		proc.Proc = bind(proc.Proc, names)
-		return proc
+		p.Proc, err = bind(p.Proc, names)
+		return p, err
 	default:
-		log.Fatal(UnknownProcessTypeError{Caller: "Bind", Proc: p})
+		return nil, UnknownProcessTypeError{Caller: "bind", Proc: p}
 	}
-	return proc
 }

bind_test.go

@@ -12,14 +12,41 @@ func TestBindIdempotent(t *testing.T) {
 		t.Fatal(err)
 	}
 	p0 := p.Calculi()
-	bp0 := Bind(p)
-	p1 := bp0.Calculi()
-	bp1 := Bind(bp0)
-	p2 := bp1.Calculi()
+	if err := Bind(&p); err != nil {
+		t.Fatal(err)
+	}
+	p1 := p.Calculi()
+	if err := Bind(&p); err != nil {
+		t.Fatal(err)
+	}
+	p2 := p.Calculi()
 	if p0 != p1 {
 		t.Errorf("expect Bind to be idempotent but got: \nBefore:\t%s\nAfter:\t%s", p0, p1)
 	}
 	if p1 != p2 {
 		t.Errorf("expect Bind to be idempotent but got: \nBefore:\t%s\nAfter:\t%s", p1, p2)
 	}
 }
+
+func TestBindRebind(t *testing.T) {
+	const proc = `(new a)(a<> | a().(new a)a().0)`
+	p, err := Parse(strings.NewReader(proc))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := Bind(&p); err != nil {
+		t.Fatalf("cannot bind: %v", err)
+	}
+	type setter interface {
+		SetName(string)
+	}
+	if s, ok := p.(*Restrict).Name.(setter); ok {
+		s.SetName("b")
+	}
+	if want, got := "b", p.(*Restrict).Proc.(*Par).Procs[1].(*Recv).Chan.Ident(); want != got {
+		t.Fatalf("expects %s but got %s for %s", want, got, p.(*Restrict).Proc.(*Par).Procs[1].(*Recv).Calculi())
+	}
+	if want, got := "a", p.(*Restrict).Proc.(*Par).Procs[1].(*Recv).Cont.(*Restrict).Name.Ident(); want != got {
+		t.Fatalf("expects %s but got %s for %s", want, got, p.(*Restrict).Proc.(*Par).Procs[1].(*Recv).Cont.(*Restrict).Calculi())
+	}
+}

codegen/golang/gen.go

@@ -26,7 +26,9 @@ import (
 
 // Generate writes Go code of the Process to w.
 func Generate(p asyncpi.Process, w io.Writer) error {
-	asyncpi.Bind(p)
+	if err := asyncpi.Bind(&p); err != nil {
+		return err
+	}
 	types.Infer(p)
 	if err := types.Unify(p); err != nil {
 		return err

codegen/golang/gen_test.go

@@ -16,7 +16,9 @@ func ExampleGenerate() {
 	if err != nil {
 		fmt.Println(err) // Parse failed
 	}
-	p = asyncpi.Bind(p)
+	if err := asyncpi.Bind(&p); err != nil {
+		fmt.Println(err)
+	}
 	types.Infer(p)
 	err = types.Unify(p)
 	if err != nil {

name/uniq_test.go

@@ -27,17 +27,19 @@ func TestUpdateName(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	bproc := asyncpi.Bind(proc)
-	if err := MakeNamesUnique(bproc); err != nil {
+	if err := asyncpi.Bind(&proc); err != nil {
+		t.Fatal(err)
+	}
+	if err := MakeNamesUnique(proc); err != nil {
 		t.Fatalf("cannot update name: %v", err)
 	}
-	if expect, got := 2, len(bproc.FreeNames()); expect != got {
-		t.Fatalf("Expecting %d unique free names, but got %d: %s", expect, got, bproc.Calculi())
+	if expect, got := 2, len(proc.FreeNames()); expect != got {
+		t.Fatalf("Expecting %d unique free names, but got %d: %s", expect, got, proc.Calculi())
 	}
-	if expect, got := 0, len(bproc.FreeVars()); expect != got {
-		t.Fatalf("Expecting %d unique free vars, but got %d: %s", expect, got, bproc.Calculi())
+	if expect, got := 0, len(proc.FreeVars()); expect != got {
+		t.Fatalf("Expecting %d unique free vars, but got %d: %s", expect, got, proc.Calculi())
 	}
-	t.Logf("%s has unique names %q", bproc.Calculi(), bproc.FreeNames())
+	t.Logf("%s has unique names %q", proc.Calculi(), proc.FreeNames())
 }
 
 func TestUpdateNamePar(t *testing.T) {
@@ -46,14 +48,16 @@ func TestUpdateNamePar(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	bproc := asyncpi.Bind(proc)
-	if err := MakeNamesUnique(bproc); err != nil {
+	if err := asyncpi.Bind(&proc); err != nil {
+		t.Fatal(err)
+	}
+	if err := MakeNamesUnique(proc); err != nil {
 		t.Fatalf("cannot update name: %v", err)
 	}
-	if expect, got := 6, len(bproc.FreeNames()); expect != got {
-		t.Fatalf("Expecting %d unique free names, but got %d: %s", expect, got, bproc.Calculi())
+	if expect, got := 6, len(proc.FreeNames()); expect != got {
+		t.Fatalf("Expecting %d unique free names, but got %d: %s", expect, got, proc.Calculi())
 	}
-	if expect, got := 0, len(bproc.FreeVars()); expect != got {
-		t.Fatalf("Expecting %d unique free vars, but got %d: %s", expect, got, bproc.Calculi())
+	if expect, got := 0, len(proc.FreeVars()); expect != got {
+		t.Fatalf("Expecting %d unique free vars, but got %d: %s", expect, got, proc.Calculi())
 	}
 }

reduce.go

@@ -154,7 +154,9 @@ func SimplifyBySC(p Process) (Process, error) {
 // Such that the unused Names and the Restrict that
 // introduced them can be removed.
 func findUnusedRestrict(p Process) (unused []Name, err error) {
-	p = Bind(p)
+	if err := Bind(&p); err != nil {
+		return nil, err
+	}
 	type rescount struct {
 		ResName Name
 		Count   int

types/infer.go

@@ -56,7 +56,9 @@ func processAttachType(p asyncpi.Process) {
 
 func Infer(p asyncpi.Process) error {
 	processAttachType(p)
-	asyncpi.Bind(p)
+	if err := asyncpi.Bind(&p); err != nil {
+		return err
+	}
 	return processInferType(p)
 }