vom/type_decoder.go - release.go.v23 - Git at Google

 // Copyright 2015 The Vanadium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.

 package vom

 import (
 	"io"
 	"sync"

 	"v.io/v23/vdl"
 	"v.io/v23/verror"
 )

 var (
 	errTypeInvalid        = verror.Register(pkgPath+".errTypeInvalid", verror.NoRetry, "{1:}{2:} vom: type {3} id {4} invalid, the min user type id is {5}{:_}")
 	errAlreadyDefined     = verror.Register(pkgPath+".errAlreadyDefined", verror.NoRetry, "{1:}{2:} vom: type {3} id {4} already defined as {5}{:_}")
 	errUnknownType        = verror.Register(pkgPath+".errUnknownType", verror.NoRetry, "{1:}{2:} vom: unknown type id {3}{:_}")
 	errEmptyName          = verror.Register(pkgPath+".errEmptyName", verror.NoRetry, "{1:}{2:} vom: NamedType has empty name{:_}")
 	errUnknownWireTypeDef = verror.Register(pkgPath+".errUnknownWireTypeDef", verror.NoRetry, "{1:}{2:} vom: unknown wire type definition {3}{:_}")
 )

 // TypeDecoder manages the receipt and unmarshalling of types from the other
 // side of a connection.  Start must be called to start decoding types,
 // and Stop must be called to reclaim resources.
 type TypeDecoder struct {
 	// The type encoder uses a 2-lock strategy for decoding. We use typeMu to lock
 	// type definitions, and use buildMu to allow only one worker to build types at
 	// a time. This is for simplifying the workflow and avoid unnecessary blocking
 	// for type lookups.
 	typeMu   sync.RWMutex
 	idToType map[typeId]*vdl.Type // GUARDED_BY(typeMu)

 	buildMu             sync.Mutex
 	buildCond           *sync.Cond
 	err                 error               // GUARDED_BY(buildMu)
 	idToWire            map[typeId]wireType // GUARDED_BY(buildMu)
 	dec                 *Decoder            // GUARDED_BY(buildMu)
 	receivedVersionByte bool                // GUARDED_BY(buildMu)

 	processingControlMu sync.Mutex
 	goroutineRunning    bool // GUARDED_BY(processingControlMu)
 	goroutineShouldStop bool // GUARDED_BY(processingControlMu)
 }

 // NewTypeDecoder returns a new TypeDecoder that reads from the given reader.
 // The TypeDecoder understands all wire type formats generated by the TypeEncoder.
 func NewTypeDecoder(r io.Reader) *TypeDecoder {
 	mr := newMessageReader(newDecbuf(r))
 	td := newTypeDecoderInternal(mr)
 	mr.SetCallbacks(td.lookupType, nil)
 	return td
 }

 func newTypeDecoderInternal(mr *messageReader) *TypeDecoder {
 	td := &TypeDecoder{
 		idToType: make(map[typeId]*vdl.Type),
 		idToWire: make(map[typeId]wireType),
 		dec: &Decoder{
 			mr:      mr,
 			typeDec: nil,
 		},
 	}
 	td.buildCond = sync.NewCond(&td.buildMu)
 	return td
 }

 func newDerivedTypeDecoderInternal(mr *messageReader, orig *TypeDecoder) *TypeDecoder {
 	td := &TypeDecoder{
 		idToType: orig.idToType,
 		idToWire: orig.idToWire,
 		dec: &Decoder{
 			mr:      mr,
 			typeDec: nil,
 		},
 	}
 	td.buildCond = sync.NewCond(&td.buildMu)
 	return td
 }

 func (d *TypeDecoder) processLoop() {
 	var err error
 	for {
 		d.processingControlMu.Lock()
 		if d.goroutineShouldStop || err != nil {
 			d.goroutineShouldStop = false
 			d.goroutineRunning = false
 			d.processingControlMu.Unlock()
 			return
 		}
 		d.processingControlMu.Unlock()
 		// Note that we will block indefinitely if the underlying
 		// read blocks on the io.Reader.
 		err = d.readSingleType()
 		d.buildMu.Lock()
 		d.err = err
 		d.buildCond.Broadcast()
 		d.buildMu.Unlock()
 		// TODO(toddw): Reconsider d.err and d.buildCond strategy.
 	}
 }

 // Start must be called to start decoding types.
 func (d *TypeDecoder) Start() {
 	d.processingControlMu.Lock()
 	d.goroutineShouldStop = false
 	if !d.goroutineRunning {
 		d.goroutineRunning = true
 		go d.processLoop()
 	}
 	d.processingControlMu.Unlock()
 }

 // Stop must be called after Start, to stop decoding types
 // and reclaim resources.  Once Stop is called,
 // subsequent Decode calls on Decoders initialized with d
 // will return errors.
 func (d *TypeDecoder) Stop() {
 	d.processingControlMu.Lock()
 	d.goroutineShouldStop = true
 	d.processingControlMu.Unlock()
 }

 // readSingleType reads a single wire type
 func (d *TypeDecoder) readSingleType() error {
 	var wt wireType
 	curTypeID, err := d.dec.decodeWireType(&wt)
 	if err != nil {
 		return err
 	}

 	// Add the wire type.
 	if err := d.addWireType(curTypeID, wt); err != nil {
 		return err
 	}

 	if !d.dec.mr.typeIncomplete {
 		if err := d.buildType(curTypeID); d.dec.mr.version != Version80 && err != nil {
 			return err
 		}
 	}

 	return nil
 }

 // LookupType returns the type for tid. If the type is not yet available,
 // this will wait until it arrives and is built.
 func (d *TypeDecoder) lookupType(tid typeId) (*vdl.Type, error) {
 	if tt := d.lookupKnownType(tid); tt != nil {
 		return tt, nil
 	}

 	d.buildMu.Lock()
 	defer d.buildMu.Unlock()
 	for {
 		if d.err != nil && d.err != io.EOF {
 			// Return any existing error immediately. Skip EOF because it
 			// may still be possible to lookup a type.
 			return nil, d.err
 		}

 		if tt := d.lookupKnownType(tid); tt != nil {
 			return tt, nil
 		}

 		if d.err != nil {
 			return nil, d.err
 		}

 		d.buildCond.Wait()
 	}
 }

 // addWireType adds the wire type wt with the type id tid.
 func (d *TypeDecoder) addWireType(tid typeId, wt wireType) error {
 	d.buildMu.Lock()
 	err := d.addWireTypeBuildLocked(tid, wt)
 	d.buildMu.Unlock()
 	return err
 }

 func (d *TypeDecoder) addWireTypeBuildLocked(tid typeId, wt wireType) error {
 	if tid < WireIdFirstUserType {
 		return verror.New(errTypeInvalid, nil, wt, tid, WireIdFirstUserType)
 	}
 	// TODO(toddw): Allow duplicates according to some heuristic (e.g. only
 	// identical, or only if the later one is a "superset", etc).
 	if dup := d.lookupKnownType(tid); dup != nil {
 		return verror.New(errAlreadyDefined, nil, wt, tid, dup)
 	}
 	if dup := d.idToWire[tid]; dup != nil {
 		return verror.New(errAlreadyDefined, nil, wt, tid, dup)
 	}
 	d.idToWire[tid] = wt
 	return nil
 }

 func (d *TypeDecoder) lookupKnownType(tid typeId) *vdl.Type {
 	if tt := bootstrapIdToType[tid]; tt != nil {
 		return tt
 	}
 	d.typeMu.RLock()
 	tt := d.idToType[tid]
 	d.typeMu.RUnlock()
 	return tt
 }

 // buildType builds the type from the given wire type.
 func (d *TypeDecoder) buildType(tid typeId) error {
 	builder := vdl.TypeBuilder{}
 	pending := make(map[typeId]vdl.PendingType)
 	_, err := d.makeType(tid, &builder, pending)
 	if err != nil {
 		return err
 	}
 	builder.Build()
 	types := make(map[typeId]*vdl.Type)
 	for tid, pt := range pending {
 		tt, err := pt.Built()
 		if err != nil {
 			return err
 		}
 		types[tid] = tt
 	}
 	// Add the types to idToType map.
 	d.typeMu.Lock()
 	for tid, tt := range types {
 		delete(d.idToWire, tid)
 		d.idToType[tid] = tt
 	}
 	d.typeMu.Unlock()
 	return nil
 }

 // makeType makes the pending type from its wire type representation.
 func (d *TypeDecoder) makeType(tid typeId, builder *vdl.TypeBuilder, pending map[typeId]vdl.PendingType) (vdl.PendingType, error) {
 	wt := d.idToWire[tid]
 	if wt == nil {
 		return nil, verror.New(errUnknownType, nil, tid)
 	}
 	// Make the type from its wireType representation, adding
 	// it to pending so that subsequent lookups get the pending
 	// type.  Eventually the built type will be added to dt.idToType.
 	if name := wt.(wireTypeGeneric).TypeName(); name != "" {
 		// Named types may be recursive, so we must create the named type first and
 		// add it to pending, before we make the base type. The base type may refer
 		// back to this named type, and will find it in pending.
 		namedType := builder.Named(name)
 		pending[tid] = namedType
 		if wtNamed, ok := wt.(wireTypeNamedT); ok {
 			// This is a NamedType pointing at a base type.
 			baseType, err := d.lookupOrMakeType(wtNamed.Value.Base, builder, pending)
 			if err != nil {
 				return nil, err
 			}
 			namedType.AssignBase(baseType)
 			return namedType, nil
 		}
 		// This isn't NamedType, but has a non-empty name.
 		baseType, err := d.makeBaseType(wt, builder, pending)
 		if err != nil {
 			return nil, err
 		}
 		namedType.AssignBase(baseType)
 		return namedType, nil
 	}
 	// Unnamed types are made directly from their base type.  It's fine to update
 	// pending after making the base type, since there's no way to create a
 	// recursive type based solely on unnamed vdl.
 	baseType, err := d.makeBaseType(wt, builder, pending)
 	if err != nil {
 		return nil, err
 	}
 	pending[tid] = baseType
 	return baseType, nil
 }

 func (d *TypeDecoder) makeBaseType(wt wireType, builder *vdl.TypeBuilder, pending map[typeId]vdl.PendingType) (vdl.PendingType, error) {
 	switch wt := wt.(type) {
 	case wireTypeNamedT:
 		return nil, verror.New(errEmptyName, nil, wt)
 	case wireTypeEnumT:
 		enumType := builder.Enum()
 		for _, label := range wt.Value.Labels {
 			enumType.AppendLabel(label)
 		}
 		return enumType, nil
 	case wireTypeArrayT:
 		elemType, err := d.lookupOrMakeType(wt.Value.Elem, builder, pending)
 		if err != nil {
 			return nil, err
 		}
 		return builder.Array().AssignElem(elemType).AssignLen(int(wt.Value.Len)), nil
 	case wireTypeListT:
 		elemType, err := d.lookupOrMakeType(wt.Value.Elem, builder, pending)
 		if err != nil {
 			return nil, err
 		}
 		return builder.List().AssignElem(elemType), nil
 	case wireTypeSetT:
 		keyType, err := d.lookupOrMakeType(wt.Value.Key, builder, pending)
 		if err != nil {
 			return nil, err
 		}
 		return builder.Set().AssignKey(keyType), nil
 	case wireTypeMapT:
 		keyType, err := d.lookupOrMakeType(wt.Value.Key, builder, pending)
 		if err != nil {
 			return nil, err
 		}
 		elemType, err := d.lookupOrMakeType(wt.Value.Elem, builder, pending)
 		if err != nil {
 			return nil, err
 		}
 		return builder.Map().AssignKey(keyType).AssignElem(elemType), nil
 	case wireTypeStructT:
 		structType := builder.Struct()
 		for _, field := range wt.Value.Fields {
 			fieldType, err := d.lookupOrMakeType(field.Type, builder, pending)
 			if err != nil {
 				return nil, err
 			}
 			structType.AppendField(field.Name, fieldType)
 		}
 		return structType, nil
 	case wireTypeUnionT:
 		unionType := builder.Union()
 		for _, field := range wt.Value.Fields {
 			fieldType, err := d.lookupOrMakeType(field.Type, builder, pending)
 			if err != nil {
 				return nil, err
 			}
 			unionType.AppendField(field.Name, fieldType)
 		}
 		return unionType, nil
 	case wireTypeOptionalT:
 		elemType, err := d.lookupOrMakeType(wt.Value.Elem, builder, pending)
 		if err != nil {
 			return nil, err
 		}
 		return builder.Optional().AssignElem(elemType), nil
 	default:
 		return nil, verror.New(errUnknownWireTypeDef, nil, wt)
 	}
 }

 func (d *TypeDecoder) lookupOrMakeType(tid typeId, builder *vdl.TypeBuilder, pending map[typeId]vdl.PendingType) (vdl.TypeOrPending, error) {
 	if tt := d.lookupKnownType(tid); tt != nil {
 		return tt, nil
 	}
 	if p, ok := pending[tid]; ok {
 		return p, nil
 	}
 	return d.makeType(tid, builder, pending)
 }
	// Copyright 2015 The Vanadium Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style
	// license that can be found in the LICENSE file.

	package vom

	import (
	"io"
	"sync"

	"v.io/v23/vdl"
	"v.io/v23/verror"
	)

	var (
	errTypeInvalid = verror.Register(pkgPath+".errTypeInvalid", verror.NoRetry, "{1:}{2:} vom: type {3} id {4} invalid, the min user type id is {5}{:_}")
	errAlreadyDefined = verror.Register(pkgPath+".errAlreadyDefined", verror.NoRetry, "{1:}{2:} vom: type {3} id {4} already defined as {5}{:_}")
	errUnknownType = verror.Register(pkgPath+".errUnknownType", verror.NoRetry, "{1:}{2:} vom: unknown type id {3}{:_}")
	errEmptyName = verror.Register(pkgPath+".errEmptyName", verror.NoRetry, "{1:}{2:} vom: NamedType has empty name{:_}")
	errUnknownWireTypeDef = verror.Register(pkgPath+".errUnknownWireTypeDef", verror.NoRetry, "{1:}{2:} vom: unknown wire type definition {3}{:_}")
	)

	// TypeDecoder manages the receipt and unmarshalling of types from the other
	// side of a connection. Start must be called to start decoding types,
	// and Stop must be called to reclaim resources.
	type TypeDecoder struct {
	// The type encoder uses a 2-lock strategy for decoding. We use typeMu to lock
	// type definitions, and use buildMu to allow only one worker to build types at
	// a time. This is for simplifying the workflow and avoid unnecessary blocking
	// for type lookups.
	typeMu sync.RWMutex
	idToType map[typeId]*vdl.Type // GUARDED_BY(typeMu)

	buildMu sync.Mutex
	buildCond *sync.Cond
	err error // GUARDED_BY(buildMu)
	idToWire map[typeId]wireType // GUARDED_BY(buildMu)
	dec *Decoder // GUARDED_BY(buildMu)
	receivedVersionByte bool // GUARDED_BY(buildMu)

	processingControlMu sync.Mutex
	goroutineRunning bool // GUARDED_BY(processingControlMu)
	goroutineShouldStop bool // GUARDED_BY(processingControlMu)
	}

	// NewTypeDecoder returns a new TypeDecoder that reads from the given reader.
	// The TypeDecoder understands all wire type formats generated by the TypeEncoder.
	func NewTypeDecoder(r io.Reader) *TypeDecoder {
	mr := newMessageReader(newDecbuf(r))
	td := newTypeDecoderInternal(mr)
	mr.SetCallbacks(td.lookupType, nil)
	return td
	}

	func newTypeDecoderInternal(mr messageReader) TypeDecoder {
	td := &TypeDecoder{
	idToType: make(map[typeId]*vdl.Type),
	idToWire: make(map[typeId]wireType),
	dec: &Decoder{
	mr: mr,
	typeDec: nil,
	},
	}
	td.buildCond = sync.NewCond(&td.buildMu)
	return td
	}

	func newDerivedTypeDecoderInternal(mr messageReader, orig TypeDecoder) *TypeDecoder {
	td := &TypeDecoder{
	idToType: orig.idToType,
	idToWire: orig.idToWire,
	dec: &Decoder{
	mr: mr,
	typeDec: nil,
	},
	}
	td.buildCond = sync.NewCond(&td.buildMu)
	return td
	}

	func (d *TypeDecoder) processLoop() {
	var err error
	for {
	d.processingControlMu.Lock()
	if d.goroutineShouldStop \|\| err != nil {
	d.goroutineShouldStop = false
	d.goroutineRunning = false
	d.processingControlMu.Unlock()
	return
	}
	d.processingControlMu.Unlock()
	// Note that we will block indefinitely if the underlying
	// read blocks on the io.Reader.
	err = d.readSingleType()
	d.buildMu.Lock()
	d.err = err
	d.buildCond.Broadcast()
	d.buildMu.Unlock()
	// TODO(toddw): Reconsider d.err and d.buildCond strategy.
	}
	}

	// Start must be called to start decoding types.
	func (d *TypeDecoder) Start() {
	d.processingControlMu.Lock()
	d.goroutineShouldStop = false
	if !d.goroutineRunning {
	d.goroutineRunning = true
	go d.processLoop()
	}
	d.processingControlMu.Unlock()
	}

	// Stop must be called after Start, to stop decoding types
	// and reclaim resources. Once Stop is called,
	// subsequent Decode calls on Decoders initialized with d
	// will return errors.
	func (d *TypeDecoder) Stop() {
	d.processingControlMu.Lock()
	d.goroutineShouldStop = true
	d.processingControlMu.Unlock()
	}

	// readSingleType reads a single wire type
	func (d *TypeDecoder) readSingleType() error {
	var wt wireType
	curTypeID, err := d.dec.decodeWireType(&wt)
	if err != nil {
	return err
	}

	// Add the wire type.
	if err := d.addWireType(curTypeID, wt); err != nil {
	return err
	}

	if !d.dec.mr.typeIncomplete {
	if err := d.buildType(curTypeID); d.dec.mr.version != Version80 && err != nil {
	return err
	}
	}

	return nil
	}

	// LookupType returns the type for tid. If the type is not yet available,
	// this will wait until it arrives and is built.
	func (d TypeDecoder) lookupType(tid typeId) (vdl.Type, error) {
	if tt := d.lookupKnownType(tid); tt != nil {
	return tt, nil
	}

	d.buildMu.Lock()
	defer d.buildMu.Unlock()
	for {
	if d.err != nil && d.err != io.EOF {
	// Return any existing error immediately. Skip EOF because it
	// may still be possible to lookup a type.
	return nil, d.err
	}

	if tt := d.lookupKnownType(tid); tt != nil {
	return tt, nil
	}

	if d.err != nil {
	return nil, d.err
	}

	d.buildCond.Wait()
	}
	}

	// addWireType adds the wire type wt with the type id tid.
	func (d *TypeDecoder) addWireType(tid typeId, wt wireType) error {
	d.buildMu.Lock()
	err := d.addWireTypeBuildLocked(tid, wt)
	d.buildMu.Unlock()
	return err
	}

	func (d *TypeDecoder) addWireTypeBuildLocked(tid typeId, wt wireType) error {
	if tid < WireIdFirstUserType {
	return verror.New(errTypeInvalid, nil, wt, tid, WireIdFirstUserType)
	}
	// TODO(toddw): Allow duplicates according to some heuristic (e.g. only
	// identical, or only if the later one is a "superset", etc).
	if dup := d.lookupKnownType(tid); dup != nil {
	return verror.New(errAlreadyDefined, nil, wt, tid, dup)
	}
	if dup := d.idToWire[tid]; dup != nil {
	return verror.New(errAlreadyDefined, nil, wt, tid, dup)
	}
	d.idToWire[tid] = wt
	return nil
	}

	func (d TypeDecoder) lookupKnownType(tid typeId) vdl.Type {
	if tt := bootstrapIdToType[tid]; tt != nil {
	return tt
	}
	d.typeMu.RLock()
	tt := d.idToType[tid]
	d.typeMu.RUnlock()
	return tt
	}

	// buildType builds the type from the given wire type.
	func (d *TypeDecoder) buildType(tid typeId) error {
	builder := vdl.TypeBuilder{}
	pending := make(map[typeId]vdl.PendingType)
	_, err := d.makeType(tid, &builder, pending)
	if err != nil {
	return err
	}
	builder.Build()
	types := make(map[typeId]*vdl.Type)
	for tid, pt := range pending {
	tt, err := pt.Built()
	if err != nil {
	return err
	}
	types[tid] = tt
	}
	// Add the types to idToType map.
	d.typeMu.Lock()
	for tid, tt := range types {
	delete(d.idToWire, tid)
	d.idToType[tid] = tt
	}
	d.typeMu.Unlock()
	return nil
	}

	// makeType makes the pending type from its wire type representation.
	func (d TypeDecoder) makeType(tid typeId, builder vdl.TypeBuilder, pending map[typeId]vdl.PendingType) (vdl.PendingType, error) {
	wt := d.idToWire[tid]
	if wt == nil {
	return nil, verror.New(errUnknownType, nil, tid)
	}
	// Make the type from its wireType representation, adding
	// it to pending so that subsequent lookups get the pending
	// type. Eventually the built type will be added to dt.idToType.
	if name := wt.(wireTypeGeneric).TypeName(); name != "" {
	// Named types may be recursive, so we must create the named type first and
	// add it to pending, before we make the base type. The base type may refer
	// back to this named type, and will find it in pending.
	namedType := builder.Named(name)
	pending[tid] = namedType
	if wtNamed, ok := wt.(wireTypeNamedT); ok {
	// This is a NamedType pointing at a base type.
	baseType, err := d.lookupOrMakeType(wtNamed.Value.Base, builder, pending)
	if err != nil {
	return nil, err
	}
	namedType.AssignBase(baseType)
	return namedType, nil
	}
	// This isn't NamedType, but has a non-empty name.
	baseType, err := d.makeBaseType(wt, builder, pending)
	if err != nil {
	return nil, err
	}
	namedType.AssignBase(baseType)
	return namedType, nil
	}
	// Unnamed types are made directly from their base type. It's fine to update
	// pending after making the base type, since there's no way to create a
	// recursive type based solely on unnamed vdl.
	baseType, err := d.makeBaseType(wt, builder, pending)
	if err != nil {
	return nil, err
	}
	pending[tid] = baseType
	return baseType, nil
	}

	func (d TypeDecoder) makeBaseType(wt wireType, builder vdl.TypeBuilder, pending map[typeId]vdl.PendingType) (vdl.PendingType, error) {
	switch wt := wt.(type) {
	case wireTypeNamedT:
	return nil, verror.New(errEmptyName, nil, wt)
	case wireTypeEnumT:
	enumType := builder.Enum()
	for _, label := range wt.Value.Labels {
	enumType.AppendLabel(label)
	}
	return enumType, nil
	case wireTypeArrayT:
	elemType, err := d.lookupOrMakeType(wt.Value.Elem, builder, pending)
	if err != nil {
	return nil, err
	}
	return builder.Array().AssignElem(elemType).AssignLen(int(wt.Value.Len)), nil
	case wireTypeListT:
	elemType, err := d.lookupOrMakeType(wt.Value.Elem, builder, pending)
	if err != nil {
	return nil, err
	}
	return builder.List().AssignElem(elemType), nil
	case wireTypeSetT:
	keyType, err := d.lookupOrMakeType(wt.Value.Key, builder, pending)
	if err != nil {
	return nil, err
	}
	return builder.Set().AssignKey(keyType), nil
	case wireTypeMapT:
	keyType, err := d.lookupOrMakeType(wt.Value.Key, builder, pending)
	if err != nil {
	return nil, err
	}
	elemType, err := d.lookupOrMakeType(wt.Value.Elem, builder, pending)
	if err != nil {
	return nil, err
	}
	return builder.Map().AssignKey(keyType).AssignElem(elemType), nil
	case wireTypeStructT:
	structType := builder.Struct()
	for _, field := range wt.Value.Fields {
	fieldType, err := d.lookupOrMakeType(field.Type, builder, pending)
	if err != nil {
	return nil, err
	}
	structType.AppendField(field.Name, fieldType)
	}
	return structType, nil
	case wireTypeUnionT:
	unionType := builder.Union()
	for _, field := range wt.Value.Fields {
	fieldType, err := d.lookupOrMakeType(field.Type, builder, pending)
	if err != nil {
	return nil, err
	}
	unionType.AppendField(field.Name, fieldType)
	}
	return unionType, nil
	case wireTypeOptionalT:
	elemType, err := d.lookupOrMakeType(wt.Value.Elem, builder, pending)
	if err != nil {
	return nil, err
	}
	return builder.Optional().AssignElem(elemType), nil
	default:
	return nil, verror.New(errUnknownWireTypeDef, nil, wt)
	}
	}

	func (d TypeDecoder) lookupOrMakeType(tid typeId, builder vdl.TypeBuilder, pending map[typeId]vdl.PendingType) (vdl.TypeOrPending, error) {
	if tt := d.lookupKnownType(tid); tt != nil {
	return tt, nil
	}
	if p, ok := pending[tid]; ok {
	return p, nil
	}
	return d.makeType(tid, builder, pending)
	}