Rename Name.Name() to Name.Ident().

nickng · nickng · commit a5f73b9467f9 · 2018-02-02T14:59:26.000Z
Name.Name makes embedding of Name difficult.
diff --git a/asyncpi.go b/asyncpi.go
@@ -12,20 +12,20 @@ import (
 type Name interface {
 	FreeNames() []Name
 	FreeVars() []Name
-	Name() string
+	Ident() string
 }
 
 type names []Name
 
-func (n names) Less(i, j int) bool { return n[i].Name() < n[j].Name() }
+func (n names) Less(i, j int) bool { return n[i].Ident() < n[j].Ident() }
 
 // remDup removes duplicate Names from sorted []Name.
 func remDup(names []Name) []Name {
 	m := make(map[string]bool)
 	for _, name := range names {
-		if _, seen := m[name.Name()]; !seen {
+		if _, seen := m[name.Ident()]; !seen {
 			names[len(m)] = name
-			m[name.Name()] = true
+			m[name.Ident()] = true
 		}
 	}
 	return names[:len(m)]
@@ -147,10 +147,10 @@ func (r *Recv) FreeVars() []Name {
 
 	ffv := fv[:0] // filtered
 	for i, j := 0, 0; i < len(fv); i++ {
-		for j < len(r.Vars) && r.Vars[j].Name() < fv[i].Name() {
+		for j < len(r.Vars) && r.Vars[j].Ident() < fv[i].Ident() {
 			j++
 		}
-		if j < len(r.Vars) && r.Vars[j].Name() != fv[i].Name() { // overshoot
+		if j < len(r.Vars) && r.Vars[j].Ident() != fv[i].Ident() { // overshoot
 			ffv = append(ffv, fv[i])
 		} else if i >= len(r.Vars) { // remaining
 			ffv = append(ffv, fv[i])
@@ -162,7 +162,7 @@ func (r *Recv) FreeVars() []Name {
 }
 
 func (r *Recv) String() string {
-	return fmt.Sprintf("recv(%s,%s).%s", r.Chan.Name(), r.Vars, r.Cont)
+	return fmt.Sprintf("recv(%s,%s).%s", r.Chan.Ident(), r.Vars, r.Cont)
 }
 
 // Repeat is a replicated Process.
@@ -273,5 +273,5 @@ func (s *Send) FreeVars() []Name {
 }
 
 func (s *Send) String() string {
-	return fmt.Sprintf("send(%s,%s)", s.Chan.Name(), s.Vals)
+	return fmt.Sprintf("send(%s,%s)", s.Chan.Ident(), s.Vals)
 }
diff --git a/asyncpi_test.go b/asyncpi_test.go
@@ -55,7 +55,7 @@ func init() {
 func TestFreeName(t *testing.T) {
 	name := newPiName("a")
 	freeNames := name.FreeNames()
-	if len(freeNames) == 1 && freeNames[0].Name() != name.Name() {
+	if len(freeNames) == 1 && freeNames[0].Ident() != name.Ident() {
 		t.Errorf("FreeName: fn(a) does not match a: `%s` vs `%s`", freeNames, name)
 	}
 }
@@ -74,7 +74,7 @@ func TestFreeNames(t *testing.T) {
 		t.Fail()
 	}
 	for i := range piNames {
-		if piNames[i].Name() != freeNames[i].Name() {
+		if piNames[i].Ident() != freeNames[i].Ident() {
 			t.Errorf("FreeNames: fn(a...) does not match a...: `%s` vs `%s`", freeNames, piNames)
 		}
 	}
@@ -119,7 +119,7 @@ func TestParFreeVar(t *testing.T) {
 	}
 	for i := range test.FreeNames {
 		fn := proc.FreeNames()[i]
-		if fn.Name() != test.FreeNames[i].Name() {
+		if fn.Ident() != test.FreeNames[i].Ident() {
 			t.Errorf("FreeNames(par): parsed and test case do not match: `%s` vs `%s`",
 				fn, test.FreeNames[i])
 		}
diff --git a/bind.go b/bind.go
@@ -33,7 +33,7 @@ func bind(p Process, boundNames []Name) Process {
 		for _, v := range proc.Vars {
 			for j := 0; j < len(names)-len(proc.Vars); j++ {
 				if IsSameName(v, names[j]) {
-					log.Println("Warning: rebinding name", v.Name(), "in recv")
+					log.Println("Warning: rebinding name", v.Ident(), "in recv")
 					names = append(names[:j], names[j+1:]...)
 				}
 			}
@@ -74,7 +74,7 @@ func bind(p Process, boundNames []Name) Process {
 		names := append(boundNames, proc.Name)
 		for i := 0; i < len(names)-1; i++ {
 			if IsSameName(proc.Name, names[i]) {
-				log.Println("Warning: rebinding name", proc.Name.Name(), "in restrict")
+				log.Println("Warning: rebinding name", proc.Name.Ident(), "in restrict")
 				names = append(names[:i], names[i+1:]...)
 			}
 		}
diff --git a/calculi.go b/calculi.go
@@ -25,19 +25,19 @@ const parTmpl = `(
 {{- if $i }} | {{ end -}}{{- $p.Calculi -}}
 {{- end -}})`
 
-const recvTmpl = `{{- .Chan.Name -}}(
+const recvTmpl = `{{- .Chan.Ident -}}(
 {{- range $i, $v := .Vars -}}
-{{- if $i -}},{{- end -}}{{- $v.Name -}}
+{{- if $i -}},{{- end -}}{{- $v.Ident -}}
 {{- end -}}).{{ .Cont.Calculi }}`
 
-const sendTmpl = `{{- .Chan.Name -}}<
+const sendTmpl = `{{- .Chan.Ident -}}<
 {{- range $i, $v := .Vals -}}
-{{- if $i -}},{{- end -}}{{- $v.Name -}}
+{{- if $i -}},{{- end -}}{{- $v.Ident -}}
 {{- end -}}>`
 
 const repTmpl = `!{{- .Proc.Calculi -}}`
 
-const resTmpl = `(new {{ .Name.Name -}}){{- .Proc.Calculi -}}`
+const resTmpl = `(new {{ .Name.Ident -}}){{- .Proc.Calculi -}}`
 
 var (
 	parT  = template.Must(template.New("").Parse(parTmpl))
diff --git a/codegen/golang/gen.go b/codegen/golang/gen.go
@@ -63,13 +63,13 @@ func gen(p asyncpi.Process, w io.Writer) error {
 		return nil
 	case *asyncpi.Restrict:
 		if chType, ok := p.Name.(types.TypedName).Type().(*types.Chan); ok { // channel is treated differently.
-			w.Write([]byte(fmt.Sprintf("%s := make(%s); ", p.Name.(types.TypedName).Name(), chType.String())))
+			w.Write([]byte(fmt.Sprintf("%s := make(%s); ", p.Name.(types.TypedName).Ident(), chType.String())))
 			if err := gen(p.Proc, w); err != nil {
 				return err
 			}
 			return nil
 		}
-		w.Write([]byte(fmt.Sprintf("var %s %s; ", p.Name.Name(), p.Name.(types.TypedName).Type())))
+		w.Write([]byte(fmt.Sprintf("var %s %s; ", p.Name.Ident(), p.Name.(types.TypedName).Type())))
 		if err := gen(p.Proc, w); err != nil {
 			return err
 		}
@@ -78,16 +78,16 @@ func gen(p asyncpi.Process, w io.Writer) error {
 		var buf bytes.Buffer
 		switch len(p.Vars) {
 		case 0:
-			buf.WriteString(fmt.Sprintf("<-%s;", p.Chan.Name()))
+			buf.WriteString(fmt.Sprintf("<-%s;", p.Chan.Ident()))
 		case 1:
-			buf.WriteString(fmt.Sprintf("%s := <-%s;", p.Vars[0].Name(), p.Chan.Name()))
+			buf.WriteString(fmt.Sprintf("%s := <-%s;", p.Vars[0].Ident(), p.Chan.Ident()))
 		default:
-			buf.WriteString(fmt.Sprintf("rcvd := <-%s;", p.Chan.Name()))
+			buf.WriteString(fmt.Sprintf("rcvd := <-%s;", p.Chan.Ident()))
 			for i, v := range p.Vars {
 				if i != 0 {
 					buf.WriteRune(',')
 				}
-				buf.WriteString(fmt.Sprintf("%s", v.Name()))
+				buf.WriteString(fmt.Sprintf("%s", v.Ident()))
 			}
 			buf.WriteString(":=")
 			for i := 0; i < len(p.Vars); i++ {
@@ -107,11 +107,11 @@ func gen(p asyncpi.Process, w io.Writer) error {
 		var buf bytes.Buffer
 		switch len(p.Vals) {
 		case 0:
-			buf.WriteString(fmt.Sprintf("%s <- struct{}{};", p.Chan.Name()))
+			buf.WriteString(fmt.Sprintf("%s <- struct{}{};", p.Chan.Ident()))
 		case 1:
-			buf.WriteString(fmt.Sprintf("%s <- %s;", p.Chan.Name(), p.Vals[0].Name()))
+			buf.WriteString(fmt.Sprintf("%s <- %s;", p.Chan.Ident(), p.Vals[0].Ident()))
 		default:
-			buf.WriteString(fmt.Sprintf("%s <- struct {", p.Chan.Name()))
+			buf.WriteString(fmt.Sprintf("%s <- struct {", p.Chan.Ident()))
 			for i := 0; i < len(p.Vals); i++ {
 				if i != 0 {
 					buf.WriteRune(';')
@@ -123,7 +123,7 @@ func gen(p asyncpi.Process, w io.Writer) error {
 				if i != 0 {
 					buf.WriteRune(',')
 				}
-				buf.WriteString(v.Name())
+				buf.WriteString(v.Ident())
 			}
 			buf.WriteString(fmt.Sprintf("}"))
 		}
diff --git a/errors.go b/errors.go
@@ -22,7 +22,7 @@ type ImmutableNameError struct {
 }
 
 func (e ImmutableNameError) Error() string {
-	return fmt.Sprintf("cannot modify name %v: immutable implementation of Name", e.Name.Name())
+	return fmt.Sprintf("cannot modify name %v: immutable implementation of Name", e.Name.Ident())
 }
 
 // UnknownProcessTypeError is the type of error for an unknown process type.
diff --git a/names.go b/names.go
@@ -43,8 +43,8 @@ func (n *piName) FreeVars() []Name {
 	return []Name{}
 }
 
-// Name is the string identifier of a name.
-func (n *piName) Name() string {
+// Ident is the string identifier of a name.
+func (n *piName) Ident() string {
 	return n.name
 }
 
@@ -86,8 +86,8 @@ func (n *hintedName) FreeVars() []Name {
 	return n.name.FreeVars()
 }
 
-func (n *hintedName) Name() string {
-	return n.name.Name()
+func (n *hintedName) Ident() string {
+	return n.name.Ident()
 }
 
 // TypeHint returns the type hint attached to given Name.
@@ -115,7 +115,7 @@ func (u *Uniquefier) visit(n Name) string {
 	if un, ok := u.names[n]; ok {
 		return un
 	}
-	s := fmt.Sprintf("%s_%d", n.Name(), len(u.names))
+	s := fmt.Sprintf("%s_%d", n.Ident(), len(u.names))
 	u.names[n] = s
 	return s
 }
@@ -176,9 +176,9 @@ func UpdateName(proc Process, a NameVisitor) error {
 // A Name x is equal with another Name y when x and y has the same name.
 // This comparison ignores the underlying representation (sort, type, etc.).
 func IsSameName(x, y Name) bool {
-	return x.Name() == y.Name()
+	return x.Ident() == y.Ident()
 }
 
 func IsFreeName(x Name) bool {
-	return len(x.FreeNames()) == 1 && x.FreeNames()[0].Name() == x.Name()
+	return len(x.FreeNames()) == 1 && x.FreeNames()[0].Ident() == x.Ident()
 }
diff --git a/reduce.go b/reduce.go
@@ -23,13 +23,13 @@ func Subst(p Process, vs, xs []Name) error {
 			for i, x := range xs {
 				if IsSameName(p.Chan, x) {
 					if ch, canSetName := p.Chan.(nameSetter); canSetName {
-						ch.setName(vs[i].Name())
+						ch.setName(vs[i].Ident())
 					}
 				}
 				for _, rv := range p.Vars {
 					if IsSameName(rv, x) {
 						if ch, canSetName := rv.(nameSetter); canSetName {
-							ch.setName(vs[i].Name())
+							ch.setName(vs[i].Ident())
 						}
 					}
 				}
@@ -43,7 +43,7 @@ func Subst(p Process, vs, xs []Name) error {
 			for i, x := range xs {
 				if IsSameName(p.Chan, x) {
 					if ch, canSetName := p.Chan.(nameSetter); canSetName {
-						ch.setName(vs[i].Name())
+						ch.setName(vs[i].Ident())
 					}
 				}
 			}
@@ -75,7 +75,7 @@ func reduceOnce(p Process) (changed bool, err error) {
 					recvs = make(map[string]*Process)
 				}
 				if IsFreeName(proc.Chan) {
-					ch := proc.Chan.Name()
+					ch := proc.Chan.Ident()
 					// Do not overwrite existing subprocess with same channel.
 					// Substitution only consider leftmost available names.
 					if _, exists := recvs[ch]; !exists {
@@ -87,7 +87,7 @@ func reduceOnce(p Process) (changed bool, err error) {
 					sends = make(map[string]*Process)
 				}
 				if IsFreeName(proc.Chan) {
-					ch := proc.Chan.Name()
+					ch := proc.Chan.Ident()
 					// Do not overwrite existing subprocess with same channel.
 					// Substitution only consider leftmost available names.
 					if _, exists := sends[ch]; !exists {
@@ -166,26 +166,26 @@ func findUnusedRestrict(p Process) (unused []Name, err error) {
 		case *Par:
 			procs = append(procs, p.Procs...)
 		case *Recv:
-			if rc, exists := resUses[p.Chan.Name()]; exists {
+			if rc, exists := resUses[p.Chan.Ident()]; exists {
 				rc.Count++
 			}
 			for _, v := range p.Vars {
-				if rc, exists := resUses[v.Name()]; exists {
+				if rc, exists := resUses[v.Ident()]; exists {
 					rc.Count++
 				}
 			}
 			procs = append(procs, p.Cont)
 		case *Repeat:
 			procs = append(procs, p.Proc)
 		case *Restrict:
-			resUses[p.Name.Name()] = &rescount{ResName: p.Name, Count: 1}
+			resUses[p.Name.Ident()] = &rescount{ResName: p.Name, Count: 1}
 			procs = append(procs, p.Proc)
 		case *Send:
-			if rc, exists := resUses[p.Chan.Name()]; exists {
+			if rc, exists := resUses[p.Chan.Ident()]; exists {
 				rc.Count++
 			}
 			for _, v := range p.Vals {
-				if rc, exists := resUses[v.Name()]; exists {
+				if rc, exists := resUses[v.Ident()]; exists {
 					rc.Count++
 
 				}
diff --git a/reduce_test.go b/reduce_test.go
@@ -26,7 +26,7 @@ func TestReduceSendRecv(t *testing.T) {
 	if !ok {
 		t.Fatalf("expects *Recv but got %s (type %T)", p.Calculi(), p)
 	}
-	if want, got := "b", p2.Chan.Name(); want != got {
+	if want, got := "b", p2.Chan.Ident(); want != got {
 		t.Fatalf("expects receive on %s but got %s", want, got)
 	}
 	_, ok = p2.Cont.(*NilProcess)
@@ -56,7 +56,7 @@ func TestReduceRecvSend(t *testing.T) {
 	if !ok {
 		t.Fatalf("expects *Send but got %s (type %T)", p.Calculi(), p)
 	}
-	if want, got := "b", p2.Chan.Name(); want != got {
+	if want, got := "b", p2.Chan.Ident(); want != got {
 		t.Fatalf("expects send on %s but got %s", want, got)
 	}
 }
@@ -82,14 +82,14 @@ func TestReduceBoundRecvSend(t *testing.T) {
 	if !ok {
 		t.Fatalf("expects a *Restrict but got %s (type %T)", p.Calculi(), p)
 	}
-	if want, got := "b", p2.Name.Name(); want != got {
+	if want, got := "b", p2.Name.Ident(); want != got {
 		t.Fatalf("expects restrict on %s but got %s", want, got)
 	}
 	p3, ok := p2.Proc.(*Send)
 	if !ok {
 		t.Fatalf("expects *Send but got %s (type %T)", p2.Calculi(), p2)
 	}
-	if want, got := "b", p3.Chan.Name(); want != got {
+	if want, got := "b", p3.Chan.Ident(); want != got {
 		t.Fatalf("expects send on %s but got %s", want, got)
 	}
 }
diff --git a/sorts.go b/sorts.go
@@ -104,11 +104,11 @@ func ResetSorts(proc Process) {
 type NameVarSorter struct{}
 
 func (s *NameVarSorter) visit(n Name) string {
-	r, _ := utf8.DecodeRuneInString(n.Name())
+	r, _ := utf8.DecodeRuneInString(n.Ident())
 	if strings.ContainsRune("nopqrstuvwxyz", r) {
 		if s, ok := n.(sortSetter); ok {
 			s.setSort(varSort)
 		}
 	}
-	return n.Name()
+	return n.Ident()
 }
diff --git a/sorts_test.go b/sorts_test.go
@@ -6,11 +6,11 @@ func TestDefaultSort(t *testing.T) {
 	n := newPiName("name")
 	if expect, got := 1, len(n.FreeNames()); expect != got {
 		t.Errorf("Expecting %s to have %d free names but got %d. fn(%s) = %s",
-			n.Name(), expect, got, n.Name(), n.FreeNames())
+			n.Ident(), expect, got, n.Ident(), n.FreeNames())
 	}
 	if expect, got := 0, len(n.FreeVars()); expect != got {
 		t.Errorf("Expecting %s to have %d free vars but got %d. fv(%s) = %s",
-			n.Name(), expect, got, n.Name(), n.FreeVars())
+			n.Ident(), expect, got, n.Ident(), n.FreeVars())
 	}
 }
 
@@ -149,18 +149,18 @@ func TestNameVarSort(t *testing.T) {
 	p.Vars = append(p.Vars, b, x, y, z)
 	UpdateName(p, new(NameVarSorter))
 	if expect, got := nameSort, a.s; expect != got {
-		t.Errorf("Expecting %s sort to be %d but got %d.", a.Name(), expect, got)
+		t.Errorf("Expecting %s sort to be %d but got %d.", a.Ident(), expect, got)
 	}
 	if expect, got := nameSort, b.s; expect != got {
-		t.Errorf("Expecting %s sort to be %d but got %d.", b.Name(), expect, got)
+		t.Errorf("Expecting %s sort to be %d but got %d.", b.Ident(), expect, got)
 	}
 	if expect, got := varSort, x.s; expect != got {
-		t.Errorf("Expecting %s sort to be %d but got %d.", x.Name(), expect, got)
+		t.Errorf("Expecting %s sort to be %d but got %d.", x.Ident(), expect, got)
 	}
 	if expect, got := varSort, y.s; expect != got {
-		t.Errorf("Expecting %s sort to be %d but got %d.", y.Name(), expect, got)
+		t.Errorf("Expecting %s sort to be %d but got %d.", y.Ident(), expect, got)
 	}
 	if expect, got := varSort, z.s; expect != got {
-		t.Errorf("Expecting %s sort to be %d but got %d.", z.Name(), expect, got)
+		t.Errorf("Expecting %s sort to be %d but got %d.", z.Ident(), expect, got)
 	}
 }
diff --git a/types/infer.go b/types/infer.go
diff --git a/types/name.go b/types/name.go
diff --git a/types/proctype.go b/types/proctype.go

Original file line number	Diff line number	Diff line change
`@@ -12,20 +12,20 @@ import (`
`12`	`12`	`type Name interface {`
`13`	`13`	`FreeNames() []Name`
`14`	`14`	`FreeVars() []Name`
`15`		`- Name() string`
	`15`	`+ Ident() string`
`16`	`16`	`}`
`17`	`17`
`18`	`18`	`type names []Name`
`19`	`19`
`20`		`-func (n names) Less(i, j int) bool { return n[i].Name() < n[j].Name() }`
	`20`	`+func (n names) Less(i, j int) bool { return n[i].Ident() < n[j].Ident() }`
`21`	`21`
`22`	`22`	`// remDup removes duplicate Names from sorted []Name.`
`23`	`23`	`func remDup(names []Name) []Name {`
`24`	`24`	`m := make(map[string]bool)`
`25`	`25`	`for _, name := range names {`
`26`		`- if _, seen := m[name.Name()]; !seen {`
	`26`	`+ if _, seen := m[name.Ident()]; !seen {`
`27`	`27`	`names[len(m)] = name`
`28`		`- m[name.Name()] = true`
	`28`	`+ m[name.Ident()] = true`
`29`	`29`	`}`
`30`	`30`	`}`
`31`	`31`	`return names[:len(m)]`
`@@ -147,10 +147,10 @@ func (r *Recv) FreeVars() []Name {`
`147`	`147`
`148`	`148`	`ffv := fv[:0] // filtered`
`149`	`149`	`for i, j := 0, 0; i < len(fv); i++ {`
`150`		`- for j < len(r.Vars) && r.Vars[j].Name() < fv[i].Name() {`
	`150`	`+ for j < len(r.Vars) && r.Vars[j].Ident() < fv[i].Ident() {`
`151`	`151`	`j++`
`152`	`152`	`}`
`153`		`- if j < len(r.Vars) && r.Vars[j].Name() != fv[i].Name() { // overshoot`
	`153`	`+ if j < len(r.Vars) && r.Vars[j].Ident() != fv[i].Ident() { // overshoot`
`154`	`154`	`ffv = append(ffv, fv[i])`
`155`	`155`	`} else if i >= len(r.Vars) { // remaining`
`156`	`156`	`ffv = append(ffv, fv[i])`
`@@ -162,7 +162,7 @@ func (r *Recv) FreeVars() []Name {`
`162`	`162`	`}`
`163`	`163`
`164`	`164`	`func (r *Recv) String() string {`
`165`		`- return fmt.Sprintf("recv(%s,%s).%s", r.Chan.Name(), r.Vars, r.Cont)`
	`165`	`+ return fmt.Sprintf("recv(%s,%s).%s", r.Chan.Ident(), r.Vars, r.Cont)`
`166`	`166`	`}`
`167`	`167`
`168`	`168`	`// Repeat is a replicated Process.`
`@@ -273,5 +273,5 @@ func (s *Send) FreeVars() []Name {`
`273`	`273`	`}`
`274`	`274`
`275`	`275`	`func (s *Send) String() string {`
`276`		`- return fmt.Sprintf("send(%s,%s)", s.Chan.Name(), s.Vals)`
	`276`	`+ return fmt.Sprintf("send(%s,%s)", s.Chan.Ident(), s.Vals)`
`277`	`277`	`}`
Original file line number	Diff line number	Diff line change
`@@ -55,7 +55,7 @@ func init() {`
`55`	`55`	`func TestFreeName(t *testing.T) {`
`56`	`56`	`name := newPiName("a")`
`57`	`57`	`freeNames := name.FreeNames()`
`58`		`- if len(freeNames) == 1 && freeNames[0].Name() != name.Name() {`
	`58`	`+ if len(freeNames) == 1 && freeNames[0].Ident() != name.Ident() {`
`59`	`59`	t.Errorf("FreeName: fn(a) does not match a: `%s` vs `%s`", freeNames, name)
`60`	`60`	`}`
`61`	`61`	`}`
`@@ -74,7 +74,7 @@ func TestFreeNames(t *testing.T) {`
`74`	`74`	`t.Fail()`
`75`	`75`	`}`
`76`	`76`	`for i := range piNames {`
`77`		`- if piNames[i].Name() != freeNames[i].Name() {`
	`77`	`+ if piNames[i].Ident() != freeNames[i].Ident() {`
`78`	`78`	t.Errorf("FreeNames: fn(a...) does not match a...: `%s` vs `%s`", freeNames, piNames)
`79`	`79`	`}`
`80`	`80`	`}`
`@@ -119,7 +119,7 @@ func TestParFreeVar(t *testing.T) {`
`119`	`119`	`}`
`120`	`120`	`for i := range test.FreeNames {`
`121`	`121`	`fn := proc.FreeNames()[i]`
`122`		`- if fn.Name() != test.FreeNames[i].Name() {`
	`122`	`+ if fn.Ident() != test.FreeNames[i].Ident() {`
`123`	`123`	t.Errorf("FreeNames(par): parsed and test case do not match: `%s` vs `%s`",
`124`	`124`	`fn, test.FreeNames[i])`
`125`	`125`	`}`
Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,7 @@ func bind(p Process, boundNames []Name) Process {`
`33`	`33`	`for _, v := range proc.Vars {`
`34`	`34`	`for j := 0; j < len(names)-len(proc.Vars); j++ {`
`35`	`35`	`if IsSameName(v, names[j]) {`
`36`		`- log.Println("Warning: rebinding name", v.Name(), "in recv")`
	`36`	`+ log.Println("Warning: rebinding name", v.Ident(), "in recv")`
`37`	`37`	`names = append(names[:j], names[j+1:]...)`
`38`	`38`	`}`
`39`	`39`	`}`
`@@ -74,7 +74,7 @@ func bind(p Process, boundNames []Name) Process {`
`74`	`74`	`names := append(boundNames, proc.Name)`
`75`	`75`	`for i := 0; i < len(names)-1; i++ {`
`76`	`76`	`if IsSameName(proc.Name, names[i]) {`
`77`		`- log.Println("Warning: rebinding name", proc.Name.Name(), "in restrict")`
	`77`	`+ log.Println("Warning: rebinding name", proc.Name.Ident(), "in restrict")`
`78`	`78`	`names = append(names[:i], names[i+1:]...)`
`79`	`79`	`}`
`80`	`80`	`}`
Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@ type ImmutableNameError struct {`
`22`	`22`	`}`
`23`	`23`
`24`	`24`	`func (e ImmutableNameError) Error() string {`
`25`		`- return fmt.Sprintf("cannot modify name %v: immutable implementation of Name", e.Name.Name())`
	`25`	`+ return fmt.Sprintf("cannot modify name %v: immutable implementation of Name", e.Name.Ident())`
`26`	`26`	`}`
`27`	`27`
`28`	`28`	`// UnknownProcessTypeError is the type of error for an unknown process type.`
Original file line number	Diff line number	Diff line change
`@@ -43,8 +43,8 @@ func (n *piName) FreeVars() []Name {`
`43`	`43`	`return []Name{}`
`44`	`44`	`}`
`45`	`45`
`46`		`-// Name is the string identifier of a name.`
`47`		`-func (n *piName) Name() string {`
	`46`	`+// Ident is the string identifier of a name.`
	`47`	`+func (n *piName) Ident() string {`
`48`	`48`	`return n.name`
`49`	`49`	`}`
`50`	`50`
`@@ -86,8 +86,8 @@ func (n *hintedName) FreeVars() []Name {`
`86`	`86`	`return n.name.FreeVars()`
`87`	`87`	`}`
`88`	`88`
`89`		`-func (n *hintedName) Name() string {`
`90`		`- return n.name.Name()`
	`89`	`+func (n *hintedName) Ident() string {`
	`90`	`+ return n.name.Ident()`
`91`	`91`	`}`
`92`	`92`
`93`	`93`	`// TypeHint returns the type hint attached to given Name.`
`@@ -115,7 +115,7 @@ func (u *Uniquefier) visit(n Name) string {`
`115`	`115`	`if un, ok := u.names[n]; ok {`
`116`	`116`	`return un`
`117`	`117`	`}`
`118`		`- s := fmt.Sprintf("%s_%d", n.Name(), len(u.names))`
	`118`	`+ s := fmt.Sprintf("%s_%d", n.Ident(), len(u.names))`
`119`	`119`	`u.names[n] = s`
`120`	`120`	`return s`
`121`	`121`	`}`
`@@ -176,9 +176,9 @@ func UpdateName(proc Process, a NameVisitor) error {`
`176`	`176`	`// A Name x is equal with another Name y when x and y has the same name.`
`177`	`177`	`// This comparison ignores the underlying representation (sort, type, etc.).`
`178`	`178`	`func IsSameName(x, y Name) bool {`
`179`		`- return x.Name() == y.Name()`
	`179`	`+ return x.Ident() == y.Ident()`
`180`	`180`	`}`
`181`	`181`
`182`	`182`	`func IsFreeName(x Name) bool {`
`183`		`- return len(x.FreeNames()) == 1 && x.FreeNames()[0].Name() == x.Name()`
	`183`	`+ return len(x.FreeNames()) == 1 && x.FreeNames()[0].Ident() == x.Ident()`
`184`	`184`	`}`
Original file line number	Diff line number	Diff line change
`@@ -23,13 +23,13 @@ func Subst(p Process, vs, xs []Name) error {`
`23`	`23`	`for i, x := range xs {`
`24`	`24`	`if IsSameName(p.Chan, x) {`
`25`	`25`	`if ch, canSetName := p.Chan.(nameSetter); canSetName {`
`26`		`- ch.setName(vs[i].Name())`
	`26`	`+ ch.setName(vs[i].Ident())`
`27`	`27`	`}`
`28`	`28`	`}`
`29`	`29`	`for _, rv := range p.Vars {`
`30`	`30`	`if IsSameName(rv, x) {`
`31`	`31`	`if ch, canSetName := rv.(nameSetter); canSetName {`
`32`		`- ch.setName(vs[i].Name())`
	`32`	`+ ch.setName(vs[i].Ident())`
`33`	`33`	`}`
`34`	`34`	`}`
`35`	`35`	`}`
`@@ -43,7 +43,7 @@ func Subst(p Process, vs, xs []Name) error {`
`43`	`43`	`for i, x := range xs {`
`44`	`44`	`if IsSameName(p.Chan, x) {`
`45`	`45`	`if ch, canSetName := p.Chan.(nameSetter); canSetName {`
`46`		`- ch.setName(vs[i].Name())`
	`46`	`+ ch.setName(vs[i].Ident())`
`47`	`47`	`}`
`48`	`48`	`}`
`49`	`49`	`}`
`@@ -75,7 +75,7 @@ func reduceOnce(p Process) (changed bool, err error) {`
`75`	`75`	`recvs = make(map[string]*Process)`
`76`	`76`	`}`
`77`	`77`	`if IsFreeName(proc.Chan) {`
`78`		`- ch := proc.Chan.Name()`
	`78`	`+ ch := proc.Chan.Ident()`
`79`	`79`	`// Do not overwrite existing subprocess with same channel.`
`80`	`80`	`// Substitution only consider leftmost available names.`
`81`	`81`	`if _, exists := recvs[ch]; !exists {`
`@@ -87,7 +87,7 @@ func reduceOnce(p Process) (changed bool, err error) {`
`87`	`87`	`sends = make(map[string]*Process)`
`88`	`88`	`}`
`89`	`89`	`if IsFreeName(proc.Chan) {`
`90`		`- ch := proc.Chan.Name()`
	`90`	`+ ch := proc.Chan.Ident()`
`91`	`91`	`// Do not overwrite existing subprocess with same channel.`
`92`	`92`	`// Substitution only consider leftmost available names.`
`93`	`93`	`if _, exists := sends[ch]; !exists {`
`@@ -166,26 +166,26 @@ func findUnusedRestrict(p Process) (unused []Name, err error) {`
`166`	`166`	`case *Par:`
`167`	`167`	`procs = append(procs, p.Procs...)`
`168`	`168`	`case *Recv:`
`169`		`- if rc, exists := resUses[p.Chan.Name()]; exists {`
	`169`	`+ if rc, exists := resUses[p.Chan.Ident()]; exists {`
`170`	`170`	`rc.Count++`
`171`	`171`	`}`
`172`	`172`	`for _, v := range p.Vars {`
`173`		`- if rc, exists := resUses[v.Name()]; exists {`
	`173`	`+ if rc, exists := resUses[v.Ident()]; exists {`
`174`	`174`	`rc.Count++`
`175`	`175`	`}`
`176`	`176`	`}`
`177`	`177`	`procs = append(procs, p.Cont)`
`178`	`178`	`case *Repeat:`
`179`	`179`	`procs = append(procs, p.Proc)`
`180`	`180`	`case *Restrict:`
`181`		`- resUses[p.Name.Name()] = &rescount{ResName: p.Name, Count: 1}`
	`181`	`+ resUses[p.Name.Ident()] = &rescount{ResName: p.Name, Count: 1}`
`182`	`182`	`procs = append(procs, p.Proc)`
`183`	`183`	`case *Send:`
`184`		`- if rc, exists := resUses[p.Chan.Name()]; exists {`
	`184`	`+ if rc, exists := resUses[p.Chan.Ident()]; exists {`
`185`	`185`	`rc.Count++`
`186`	`186`	`}`
`187`	`187`	`for _, v := range p.Vals {`
`188`		`- if rc, exists := resUses[v.Name()]; exists {`
	`188`	`+ if rc, exists := resUses[v.Ident()]; exists {`
`189`	`189`	`rc.Count++`
`190`	`190`
`191`	`191`	`}`
Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@ func TestReduceSendRecv(t *testing.T) {`
`26`	`26`	`if !ok {`
`27`	`27`	`t.Fatalf("expects *Recv but got %s (type %T)", p.Calculi(), p)`
`28`	`28`	`}`
`29`		`- if want, got := "b", p2.Chan.Name(); want != got {`
	`29`	`+ if want, got := "b", p2.Chan.Ident(); want != got {`
`30`	`30`	`t.Fatalf("expects receive on %s but got %s", want, got)`
`31`	`31`	`}`
`32`	`32`	`_, ok = p2.Cont.(*NilProcess)`
`@@ -56,7 +56,7 @@ func TestReduceRecvSend(t *testing.T) {`
`56`	`56`	`if !ok {`
`57`	`57`	`t.Fatalf("expects *Send but got %s (type %T)", p.Calculi(), p)`
`58`	`58`	`}`
`59`		`- if want, got := "b", p2.Chan.Name(); want != got {`
	`59`	`+ if want, got := "b", p2.Chan.Ident(); want != got {`
`60`	`60`	`t.Fatalf("expects send on %s but got %s", want, got)`
`61`	`61`	`}`
`62`	`62`	`}`
`@@ -82,14 +82,14 @@ func TestReduceBoundRecvSend(t *testing.T) {`
`82`	`82`	`if !ok {`
`83`	`83`	`t.Fatalf("expects a *Restrict but got %s (type %T)", p.Calculi(), p)`
`84`	`84`	`}`
`85`		`- if want, got := "b", p2.Name.Name(); want != got {`
	`85`	`+ if want, got := "b", p2.Name.Ident(); want != got {`
`86`	`86`	`t.Fatalf("expects restrict on %s but got %s", want, got)`
`87`	`87`	`}`
`88`	`88`	`p3, ok := p2.Proc.(*Send)`
`89`	`89`	`if !ok {`
`90`	`90`	`t.Fatalf("expects *Send but got %s (type %T)", p2.Calculi(), p2)`
`91`	`91`	`}`
`92`		`- if want, got := "b", p3.Chan.Name(); want != got {`
	`92`	`+ if want, got := "b", p3.Chan.Ident(); want != got {`
`93`	`93`	`t.Fatalf("expects send on %s but got %s", want, got)`
`94`	`94`	`}`
`95`	`95`	`}`
Original file line number	Diff line number	Diff line change
`@@ -104,11 +104,11 @@ func ResetSorts(proc Process) {`
`104`	`104`	`type NameVarSorter struct{}`
`105`	`105`
`106`	`106`	`func (s *NameVarSorter) visit(n Name) string {`
`107`		`- r, _ := utf8.DecodeRuneInString(n.Name())`
	`107`	`+ r, _ := utf8.DecodeRuneInString(n.Ident())`
`108`	`108`	`if strings.ContainsRune("nopqrstuvwxyz", r) {`
`109`	`109`	`if s, ok := n.(sortSetter); ok {`
`110`	`110`	`s.setSort(varSort)`
`111`	`111`	`}`
`112`	`112`	`}`
`113`		`- return n.Name()`
	`113`	`+ return n.Ident()`
`114`	`114`	`}`
Original file line number	Diff line number	Diff line change
`@@ -6,11 +6,11 @@ func TestDefaultSort(t *testing.T) {`
`6`	`6`	`n := newPiName("name")`
`7`	`7`	`if expect, got := 1, len(n.FreeNames()); expect != got {`
`8`	`8`	`t.Errorf("Expecting %s to have %d free names but got %d. fn(%s) = %s",`
`9`		`- n.Name(), expect, got, n.Name(), n.FreeNames())`
	`9`	`+ n.Ident(), expect, got, n.Ident(), n.FreeNames())`
`10`	`10`	`}`
`11`	`11`	`if expect, got := 0, len(n.FreeVars()); expect != got {`
`12`	`12`	`t.Errorf("Expecting %s to have %d free vars but got %d. fv(%s) = %s",`
`13`		`- n.Name(), expect, got, n.Name(), n.FreeVars())`
	`13`	`+ n.Ident(), expect, got, n.Ident(), n.FreeVars())`
`14`	`14`	`}`
`15`	`15`	`}`
`16`	`16`
`@@ -149,18 +149,18 @@ func TestNameVarSort(t *testing.T) {`
`149`	`149`	`p.Vars = append(p.Vars, b, x, y, z)`
`150`	`150`	`UpdateName(p, new(NameVarSorter))`
`151`	`151`	`if expect, got := nameSort, a.s; expect != got {`
`152`		`- t.Errorf("Expecting %s sort to be %d but got %d.", a.Name(), expect, got)`
	`152`	`+ t.Errorf("Expecting %s sort to be %d but got %d.", a.Ident(), expect, got)`
`153`	`153`	`}`
`154`	`154`	`if expect, got := nameSort, b.s; expect != got {`
`155`		`- t.Errorf("Expecting %s sort to be %d but got %d.", b.Name(), expect, got)`
	`155`	`+ t.Errorf("Expecting %s sort to be %d but got %d.", b.Ident(), expect, got)`
`156`	`156`	`}`
`157`	`157`	`if expect, got := varSort, x.s; expect != got {`
`158`		`- t.Errorf("Expecting %s sort to be %d but got %d.", x.Name(), expect, got)`
	`158`	`+ t.Errorf("Expecting %s sort to be %d but got %d.", x.Ident(), expect, got)`
`159`	`159`	`}`
`160`	`160`	`if expect, got := varSort, y.s; expect != got {`
`161`		`- t.Errorf("Expecting %s sort to be %d but got %d.", y.Name(), expect, got)`
	`161`	`+ t.Errorf("Expecting %s sort to be %d but got %d.", y.Ident(), expect, got)`
`162`	`162`	`}`
`163`	`163`	`if expect, got := varSort, z.s; expect != got {`
`164`		`- t.Errorf("Expecting %s sort to be %d but got %d.", z.Name(), expect, got)`
	`164`	`+ t.Errorf("Expecting %s sort to be %d but got %d.", z.Ident(), expect, got)`
`165`	`165`	`}`
`166`	`166`	`}`