Remove all copies of Schema and Map

Author: apelisse

schema/elements.go

@@ -30,11 +30,7 @@ type Schema struct {
 	once sync.Once
 	m    map[string]TypeDef
 
-	// Once used to protect the initialization of `lock` field.
-	lockOnce sync.Once
-	// Lock which protects writes to resolvedTypes. Used as pointer so that
-	// schema may be used as a value type
-	lock *sync.Mutex
+	lock sync.Mutex
 	// Cached results of resolving type references to atoms. Only stores
 	// type references which require fields of Atom to be overriden.
 	resolvedTypes map[TypeRef]Atom
@@ -163,6 +159,31 @@ func (m *Map) FindField(name string) (StructField, bool) {
 	return sf, ok
 }
 
+// CopyInto this instance of Map into the other
+// If other is nil this method does nothing.
+// If other is already initialized, overwrites it with this instance
+// Warning: Not thread safe
+func (m *Map) CopyInto(dst *Map) {
+	if dst == nil {
+		return
+	}
+
+	// Map type is considered immutable so sharing references
+	dst.Fields = m.Fields
+	dst.ElementType = m.ElementType
+	dst.Unions = m.Unions
+	dst.ElementRelationship = m.ElementRelationship
+
+	if m.m != nil {
+		// If cache is non-nil then the once token had been consumed.
+		// Must reset token and use it again to ensure same semantics.
+		dst.once = sync.Once{}
+		dst.once.Do(func() {
+			dst.m = m.m
+		})
+	}
+}
+
 // UnionFields are mapping between the fields that are part of the union and
 // their discriminated value. The discriminated value has to be set, and
 // should not conflict with other discriminated value in the list.
@@ -289,15 +310,13 @@ func (s *Schema) Resolve(tr TypeRef) (Atom, bool) {
 		return s.resolveNoOverrides(tr)
 	}
 
-	// Check to see if we have a cached version of this type
-	s.lockOnce.Do(func() {
-		s.lock = &sync.Mutex{}
-		s.resolvedTypes = make(map[TypeRef]Atom)
-	})
-
 	s.lock.Lock()
 	defer s.lock.Unlock()
 
+	if s.resolvedTypes == nil {
+		s.resolvedTypes = make(map[TypeRef]Atom)
+	}
+
 	var result Atom
 	var exists bool
 
@@ -308,7 +327,8 @@ func (s *Schema) Resolve(tr TypeRef) (Atom, bool) {
 			// Allow field-level electives to override the referred type's modifiers
 			switch {
 			case result.Map != nil:
-				mapCopy := *result.Map
+				mapCopy := Map{}
+				result.Map.CopyInto(&mapCopy)
 				mapCopy.ElementRelationship = *tr.ElementRelationship
 				result.Map = &mapCopy
 			case result.List != nil:
@@ -335,7 +355,7 @@ func (s *Schema) Resolve(tr TypeRef) (Atom, bool) {
 // If other is nil this method does nothing.
 // If other is already initialized, overwrites it with this instance
 // Warning: Not thread safe
-func (s Schema) CopyInto(dst *Schema) {
+func (s *Schema) CopyInto(dst *Schema) {
 	if dst == nil {
 		return
 	}

schema/elements_test.go

@@ -161,7 +161,7 @@ func TestCopyInto(t *testing.T) {
 			theCopy := Schema{}
 			s.CopyInto(&theCopy)
 
-			if !reflect.DeepEqual(s, theCopy) {
+			if !reflect.DeepEqual(&s, &theCopy) {
 				t.Fatal("")
 			}
 
@@ -170,7 +170,7 @@ func TestCopyInto(t *testing.T) {
 			theCopy = Schema{}
 			s.CopyInto(&theCopy)
 
-			if !reflect.DeepEqual(s, theCopy) {
+			if !reflect.DeepEqual(&s, &theCopy) {
 				t.Fatal("")
 			}
 		})

schema/equals_test.go

@@ -31,18 +31,18 @@ func fuzzInterface(i *interface{}, c fuzz.Continue) {
 	*i = &m
 }
 
-func (Schema) Generate(rand *rand.Rand, size int) reflect.Value {
+func (*Schema) Generate(rand *rand.Rand, size int) reflect.Value {
 	s := Schema{}
 	f := fuzz.New().RandSource(rand).MaxDepth(4)
 	f.Fuzz(&s)
-	return reflect.ValueOf(s)
+	return reflect.ValueOf(&s)
 }
 
-func (Map) Generate(rand *rand.Rand, size int) reflect.Value {
+func (*Map) Generate(rand *rand.Rand, size int) reflect.Value {
 	m := Map{}
 	f := fuzz.New().RandSource(rand).MaxDepth(4).Funcs(fuzzInterface)
 	f.Fuzz(&m)
-	return reflect.ValueOf(m)
+	return reflect.ValueOf(&m)
 }
 
 func (TypeDef) Generate(rand *rand.Rand, size int) reflect.Value {
@@ -73,13 +73,13 @@ func TestEquals(t *testing.T) {
 	// The "copy known fields" section of these function is to break if folks
 	// add new fields without fixing the Equals function and this test.
 	funcs := []interface{}{
-		func(x Schema) bool {
-			if !x.Equals(&x) {
+		func(x *Schema) bool {
+			if !x.Equals(x) {
 				return false
 			}
 			var y Schema
 			y.Types = x.Types
-			return x.Equals(&y) == reflect.DeepEqual(&x, &y)
+			return x.Equals(&y) == reflect.DeepEqual(x, &y)
 		},
 		func(x TypeDef) bool {
 			if !x.Equals(&x) {
@@ -109,16 +109,16 @@ func TestEquals(t *testing.T) {
 			y.Map = x.Map
 			return x.Equals(&y) == reflect.DeepEqual(x, y)
 		},
-		func(x Map) bool {
-			if !x.Equals(&x) {
+		func(x *Map) bool {
+			if !x.Equals(x) {
 				return false
 			}
 			var y Map
 			y.ElementType = x.ElementType
 			y.ElementRelationship = x.ElementRelationship
 			y.Fields = x.Fields
 			y.Unions = x.Unions
-			return x.Equals(&y) == reflect.DeepEqual(&x, &y)
+			return x.Equals(&y) == reflect.DeepEqual(x, &y)
 		},
 		func(x Union) bool {
 			if !x.Equals(&x) {