Codegen update -- Assemblers, and many new representations

.travis.yml

@@ -19,7 +19,7 @@ before_script:
 - go test -run xxxx ./...
 
 script:
-- go test -race -short -coverprofile=coverage.txt ./...
+- go test -short -coverprofile=coverage.txt ./...
 
 after_success:
 - bash <(curl -s https://codecov.io/bash)

_rsrch/methodsets/base.go

@@ -0,0 +1,15 @@
+package methodsets
+
+type Thing struct {
+	Alpha string
+	Beta  string
+}
+
+func (x *Thing) Pow() {
+	x.Alpha = "base"
+}
+
+type ThingPrivate struct {
+	a string
+	b string
+}

_rsrch/methodsets/crosspkg/isomorphicCast.go

@@ -0,0 +1,26 @@
+package crosspkg
+
+import (
+	"github.com/ipld/go-ipld-prime/_rsrch/methodsets"
+)
+
+type What struct {
+	Alpha string
+	Beta  string
+}
+
+func FlipWhat(x *methodsets.Thing) *What {
+	return (*What)(x)
+}
+
+type WhatPrivate struct {
+	a string
+	b string
+}
+
+//func FlipWhatPrivate(x *methodsets.ThingPrivate) *What {
+//	return (*WhatPrivate)(x)
+//}
+// NOPE!
+// (thank HEAVENS.)
+// ./isomorphicCast.go:22:23: cannot convert x (type *methodsets.ThingPrivate) to type *WhatPrivate

_rsrch/methodsets/viaAliases.go

@@ -0,0 +1,28 @@
+package methodsets
+
+type AliasThing = Thing
+
+// func (x *AliasThing) Pow() {}
+// NOPE!
+// ./viaAliases.go:5:22: (*Thing).Pow redeclared in this block
+//	previous declaration at ./base.go:8:6
+
+type AliasPtr = *Thing
+
+// ^ Oddly, works.
+
+// func (x *AliasPtr) Pow() {}
+// NOPE!
+// ./aliases.go:14:6: invalid receiver type **Thing (*Thing is not a defined type)
+
+// func (x AliasPtr) Pow() {}
+// NOPE!
+// ./aliases.go:18:19: (*Thing).Pow redeclared in this block
+// 	previous declaration at ./base.go:8:6
+
+/*
+	Conclusion: no joy.
+	Aliases really are a syntactic sugar thing, and do not seem to enable
+	any interesting tricks that would not otherwise be possible,
+	and certainly don't appear to get us closer to the "methodsets" semantic I yearn for.
+*/

_rsrch/methodsets/viaTypedef.go

@@ -0,0 +1,15 @@
+package methodsets
+
+type Thing2ViaTypedef Thing
+
+// This also compiles and works if you longhand the entire struct defn again...
+//  as long as it's identical, it works.
+//  (This does not extend to replacing field types with other-named but structurally identical types.)
+
+func FlipTypedef(x *Thing) *Thing2ViaTypedef {
+	return (*Thing2ViaTypedef)(x)
+}
+
+func (x *Thing2ViaTypedef) Pow() {
+	x.Alpha = "typedef"
+}

_rsrch/methodsets/viaTypedef_test.go

@@ -0,0 +1,28 @@
+package methodsets
+
+import (
+	"testing"
+
+	. "github.com/warpfork/go-wish"
+)
+
+func TestViaTypedef(t *testing.T) {
+	x := Thing{"alpha", "beta"}
+
+	x.Pow()
+	Wish(t, x, ShouldEqual, Thing{"base", "beta"})
+
+	x2 := FlipTypedef(&x)
+	Wish(t, x2, ShouldEqual, &Thing2ViaTypedef{"base", "beta"})
+
+	x2.Pow()
+	Wish(t, x2, ShouldEqual, &Thing2ViaTypedef{"typedef", "beta"})
+
+	Wish(t, x, ShouldEqual, Thing{"typedef", "beta"}) // ! effects propagate back to original.
+
+	x.Pow()
+	Wish(t, x2, ShouldEqual, &Thing2ViaTypedef{"base", "beta"}) // ! and still also vice versa.
+
+	// it's not just that we care about retaining mutability (though that's sometimes useful);
+	// it's that a 'yes' to that directly implies 'yes' to "can we get this pov without any allocations".
+}

_rsrch/methodsets/viaUnsafe.go

@@ -0,0 +1,22 @@
+package methodsets
+
+import (
+	"unsafe"
+)
+
+type Thing2ViaUnsafe struct {
+	Alpha string
+	Beta  string
+}
+
+func FlipUnsafe(x *Thing) *Thing2ViaUnsafe {
+	return (*Thing2ViaUnsafe)(unsafe.Pointer(x))
+}
+
+func UnflipUnsafe(x *Thing2ViaUnsafe) *Thing {
+	return (*Thing)(unsafe.Pointer(x))
+}
+
+func (x *Thing2ViaUnsafe) Pow() {
+	x.Alpha = "unsafe"
+}

_rsrch/methodsets/viaUnsafe_test.go

@@ -0,0 +1,28 @@
+package methodsets
+
+import (
+	"testing"
+
+	. "github.com/warpfork/go-wish"
+)
+
+func TestViaUnsafe(t *testing.T) {
+	x := Thing{"alpha", "beta"}
+
+	x.Pow()
+	Wish(t, x, ShouldEqual, Thing{"base", "beta"})
+
+	x2 := FlipUnsafe(&x)
+	Wish(t, x2, ShouldEqual, &Thing2ViaUnsafe{"base", "beta"})
+
+	x2.Pow()
+	Wish(t, x2, ShouldEqual, &Thing2ViaUnsafe{"unsafe", "beta"})
+
+	Wish(t, x, ShouldEqual, Thing{"unsafe", "beta"}) // ! effects propagate back to original.
+
+	x.Pow()
+	Wish(t, x2, ShouldEqual, &Thing2ViaUnsafe{"base", "beta"}) // ! and still also vice versa.
+
+	// it's not just that we care about retaining mutability (though that's sometimes useful);
+	// it's that a 'yes' to that directly implies 'yes' to "can we get this pov without any allocations".
+}

_rsrch/nozeros/crosspkg/zero_test.go

@@ -0,0 +1,56 @@
+package crosspkg
+
+import (
+	"testing"
+
+	. "github.com/warpfork/go-wish"
+
+	"github.com/ipld/go-ipld-prime/_rsrch/nozeros"
+)
+
+func TestStuff(t *testing.T) {
+	_ = nozeros.ExportedAlias{} // undesirable
+
+	// _ = nozeros.ExportedPtr{} // undesirable
+	// NOPE!  (Success!)
+	// ./zero.go:14:25: invalid pointer type nozeros.ExportedPtr for composite literal (use &nozeros.internal instead)
+
+	v := nozeros.NewExportedPtr("woo")
+	var typecheckMe interface{} = v
+	v2, ok := typecheckMe.(nozeros.ExportedPtr)
+
+	Wish(t, ok, ShouldEqual, true) // well, duh.  Mostly we wanted to know if even asking was allowed.
+	Wish(t, v2, ShouldEqual, v)    // well, duh.  But sanity check, I guess.
+
+	v.Pow() // check that your IDE can autocomplete this, too.  it should.
+
+	// this is all the semantics we wanted; awesome.
+	//
+	// still unfortunate: Pow won't show up in docs, since it's on an unexported type.
+
+	// exporting an alias of the non-pointer makes a hole in your guarantees, of course:
+	var hmm nozeros.ExportedPtr
+	hmm = &nozeros.ExportedAlias{}
+	_ = hmm
+}
+
+func TestStranger(t *testing.T) {
+	var foo nozeros.Foo
+	// foo = &nozeros.FooData{} // undesirable
+	// NOPE!  (Success!)
+
+	foo = nozeros.Foo(nil) // possible, yes.  but fairly irrelevant.
+	_ = foo
+
+	v := nozeros.NewFoo("woo")
+
+	Wish(t, v.Read(), ShouldEqual, "woo")
+
+	v.Pow()
+
+	Wish(t, v.Read(), ShouldEqual, "waht")
+
+	v.Pow()
+
+	t.Logf("%#v", v) // this will log the internal type name, not the exported alias.  Arguably not ideal.
+}

_rsrch/nozeros/nozeros.go

@@ -0,0 +1,43 @@
+package nozeros
+
+type internal struct {
+	x string
+}
+
+func (x *internal) Pow() {}
+
+// func (x ExportedPtr) Pow() {} // no, "invalid receiver type ExportedPtr (ExportedPtr is a pointer type)".
+// wait, no, this was only illegal for `type ExportedPtr *internal` -- AHHAH
+
+type ExportedAlias = internal
+
+type ExportedPtr = *internal
+
+// type ExportedPtr *internal // ALMOST works...
+//  except somewhat bizarrely, 'Pow()' becomes undefined and invisible on the exported type.
+//  As far as I can tell, aside from that, it's identical to using the alias.
+
+func NewExportedPtr(v string) ExportedPtr {
+	return &internal{v}
+}
+
+// ---
+
+type FooData struct {
+	x string
+}
+
+func (x Foo) Pow() {
+	x.x = "waht"
+}
+func (x Foo) Read() string {
+	return x.x
+}
+
+type foo FooData
+
+type Foo = *foo
+
+func NewFoo(v string) Foo {
+	return &foo{v}
+}

errors.go

@@ -70,6 +70,55 @@ func (e ErrRepeatedMapKey) Error() string {
 	return fmt.Sprintf("cannot repeat map key (\"%s\")", e.Key)
 }
 
+// ErrInvalidKey indicates a key is invalid for some reason.
+//
+// This is only possible for typed nodes; specifically, it may show up when
+// handling struct types, or maps with interesting key types.
+// (Other kinds of key invalidity that happen for untyped maps
+// fall under ErrRepeatedMapKey or ErrWrongKind.)
+// (Union types use ErrInvalidUnionDiscriminant instead of ErrInvalidKey,
+// even when their representation strategy is maplike.)
+type ErrInvalidKey struct {
+	// TypeName will indicate the named type of a node the function was called on.
+	TypeName string
+
+	// Key is the key that was rejected.
+	Key Node
+
+	// Reason, if set, may provide details (for example, the reason a key couldn't be converted to a type).
+	// If absent, it'll be presumed "no such field".
+	// ErrUnmatchable may show up as a reason for typed maps with complex keys.
+	Reason error
+}
+
+func (e ErrInvalidKey) Error() string {
+	if e.Reason == nil {
+		return fmt.Sprintf("invalid key for map %s: \"%s\": no such field", e.TypeName, e.Key)
+	} else {
+		return fmt.Sprintf("invalid key for map %s: \"%s\": %s", e.TypeName, e.Key, e.Reason)
+	}
+}
+
+// ErrUnmatchable is the catch-all type for parse errors in schema representation work.
+//
+// REVIEW: are builders at type level ever going to return this?  i don't think so.
+// REVIEW: can this ever be triggered during the marshalling direction?  perhaps not.
+// REVIEW: do things like ErrWrongKind end up being wrapped by this?  that doesn't seem pretty.
+// REVIEW: do natural representations ever trigger this?  i don't think so.  maybe that's a hint towards a better name.
+// REVIEW: are user validation functions encouraged to return this?  or something else?
+//
+type ErrUnmatchable struct {
+	// TypeName will indicate the named type of a node the function was called on.
+	TypeName string
+
+	// Reason must always be present.  ErrUnmatchable doesn't say much otherwise.
+	Reason error
+}
+
+func (e ErrUnmatchable) Error() string {
+	return fmt.Sprintf("parsing of %s rejected: %s", e.TypeName, e.Reason)
+}
+
 // ErrIteratorOverread is returned when calling 'Next' on a MapIterator or
 // ListIterator when it is already done.
 type ErrIteratorOverread struct{}
@@ -80,7 +129,6 @@ func (e ErrIteratorOverread) Error() string {
 
 type ErrCannotBeNull struct{} // Review: arguably either ErrInvalidKindForNodeStyle.
 
-type ErrInvalidStructKey struct{}         // only possible for typed nodes -- specifically, struct types.
 type ErrMissingRequiredField struct{}     // only possible for typed nodes -- specifically, struct types.
 type ErrListOverrun struct{}              // only possible for typed nodes -- specifically, struct types with list (aka tuple) representations.
 type ErrInvalidUnionDiscriminant struct{} // only possible for typed nodes -- specifically, union types.

kind.go

@@ -76,3 +76,12 @@ func (x ReprKindSet) String() string {
 	s += x[len(x)-1].String()
 	return s
 }
+
+func (x ReprKindSet) Contains(e ReprKind) bool {
+	for _, v := range x {
+		if v == e {
+			return true
+		}
+	}
+	return false
+}

module.tl

@@ -15,7 +15,7 @@
 				"action": {
 					"exec": [
 						"/bin/bash", "-c",
-						"export PATH=$PATH:/app/go/go/bin && export GOPATH=$PWD/.gopath && go test ./..."
+						"export PATH=$PATH:/app/go/go/bin && export GOPATH=$PWD/.gopath && go test -tags 'skipgenbehavtests' ./..."
 					]
 				}
 			}

node/basic/list.go

@@ -182,16 +182,18 @@ func (plainList__Assembler) AssignLink(ipld.Link) error {
 }
 func (na *plainList__Assembler) AssignNode(v ipld.Node) error {
 	// Sanity check, then update, assembler state.
+	//  Update of state to 'finished' comes later; where exactly depends on if shortcuts apply.
 	if na.state != laState_initial {
 		panic("misuse")
 	}
-	na.state = laState_finished
 	// Copy the content.
 	if v2, ok := v.(*plainList); ok { // if our own type: shortcut.
 		// Copy the structure by value.
 		//  This means we'll have pointers into the same internal maps and slices;
 		//   this is okay, because the Node type promises it's immutable, and we are going to instantly finish ourselves to also maintain that.
+		// FIXME: the shortcut behaves differently than the long way: it discards any existing progress.  Doesn't violate immut, but is odd.
 		*na.w = *v2
+		na.state = laState_finished
 		return nil
 	}
 	// If the above shortcut didn't work, resort to a generic copy.
@@ -209,8 +211,7 @@ func (na *plainList__Assembler) AssignNode(v ipld.Node) error {
 			return err
 		}
 	}
-	// validators could run and report errors promptly, if this type had any -- same as for regular Finish.
-	return nil
+	return na.Finish()
 }
 func (plainList__Assembler) Style() ipld.NodeStyle {
 	return Style__List{}