use pointer semantics for schema

Author: alexzielenski

internal/fixture/state.go

@@ -477,7 +477,7 @@ func (cs ChangeParser) run(state *State) error {
 	// Swap the schema in for use with the live object so it merges.
 	// If the schema is incompatible, this will fail validation.
 
-	liveWithNewSchema, err := typed.AsTyped(state.Live.AsValue(), &cs.Parser.Schema, state.Live.TypeRef())
+	liveWithNewSchema, err := typed.AsTyped(state.Live.AsValue(), cs.Parser.Schema, state.Live.TypeRef())
 	if err != nil {
 		return err
 	}

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
@@ -43,7 +39,7 @@ type Schema struct {
 // A TypeSpecifier references a particular type in a schema.
 type TypeSpecifier struct {
 	Type   TypeRef `yaml:"type,omitempty"`
-	Schema Schema  `yaml:"schema,omitempty"`
+	Schema *Schema `yaml:"schema,omitempty"`
 }
 
 // TypeDef represents a named type in a schema.
@@ -290,13 +286,9 @@ func (s *Schema) Resolve(tr TypeRef) (Atom, bool) {
 	}
 
 	// 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()
+	s.resolvedTypes = make(map[TypeRef]Atom)
 
 	var result Atom
 	var exists bool
@@ -335,7 +327,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,10 +31,10 @@ func fuzzInterface(i *interface{}, c fuzz.Continue) {
 	*i = &m
 }
 
-func (Schema) Generate(rand *rand.Rand, size int) reflect.Value {
-	s := Schema{}
+func (*Schema) Generate(rand *rand.Rand, size int) reflect.Value {
+	s := &Schema{}
 	f := fuzz.New().RandSource(rand).MaxDepth(4)
-	f.Fuzz(&s)
+	f.Fuzz(s)
 	return reflect.ValueOf(s)
 }
 
@@ -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) {

typed/parser.go

@@ -29,12 +29,14 @@ type YAMLObject string
 
 // Parser implements YAMLParser and allows introspecting the schema.
 type Parser struct {
-	Schema schema.Schema
+	Schema *schema.Schema
 }
 
 // create builds an unvalidated parser.
 func create(s YAMLObject) (*Parser, error) {
-	p := Parser{}
+	p := Parser{
+		Schema: &schema.Schema{},
+	}
 	err := yaml.Unmarshal([]byte(s), &p.Schema)
 	return &p, err
 }
@@ -74,7 +76,7 @@ func (p *Parser) TypeNames() (names []string) {
 // errors are deferred until a further function is called.
 func (p *Parser) Type(name string) ParseableType {
 	return ParseableType{
-		Schema:  &p.Schema,
+		Schema:  p.Schema,
 		TypeRef: schema.TypeRef{NamedType: &name},
 	}
 }