forked from cerc-io/ipld-eth-server
147 lines
3.5 KiB
Go
147 lines
3.5 KiB
Go
package parse
|
|
|
|
import (
|
|
"github.com/tinylib/msgp/gen"
|
|
)
|
|
|
|
// This file defines when and how we
|
|
// propagate type information from
|
|
// one type declaration to another.
|
|
// After the processing pass, every
|
|
// non-primitive type is marshalled/unmarshalled/etc.
|
|
// through a function call. Here, we propagate
|
|
// the type information into the caller's type
|
|
// tree *if* the child type is simple enough.
|
|
//
|
|
// For example, types like
|
|
//
|
|
// type A [4]int
|
|
//
|
|
// will get pushed into parent methods,
|
|
// whereas types like
|
|
//
|
|
// type B [3]map[string]struct{A, B [4]string}
|
|
//
|
|
// will not.
|
|
|
|
// this is an approximate measure
|
|
// of the number of children in a node
|
|
const maxComplex = 5
|
|
|
|
// begin recursive search for identities with the
|
|
// given name and replace them with be
|
|
func (f *FileSet) findShim(id string, be *gen.BaseElem) {
|
|
for name, el := range f.Identities {
|
|
pushstate(name)
|
|
switch el := el.(type) {
|
|
case *gen.Struct:
|
|
for i := range el.Fields {
|
|
f.nextShim(&el.Fields[i].FieldElem, id, be)
|
|
}
|
|
case *gen.Array:
|
|
f.nextShim(&el.Els, id, be)
|
|
case *gen.Slice:
|
|
f.nextShim(&el.Els, id, be)
|
|
case *gen.Map:
|
|
f.nextShim(&el.Value, id, be)
|
|
case *gen.Ptr:
|
|
f.nextShim(&el.Value, id, be)
|
|
}
|
|
popstate()
|
|
}
|
|
// we'll need this at the top level as well
|
|
f.Identities[id] = be
|
|
}
|
|
|
|
func (f *FileSet) nextShim(ref *gen.Elem, id string, be *gen.BaseElem) {
|
|
if (*ref).TypeName() == id {
|
|
vn := (*ref).Varname()
|
|
*ref = be.Copy()
|
|
(*ref).SetVarname(vn)
|
|
} else {
|
|
switch el := (*ref).(type) {
|
|
case *gen.Struct:
|
|
for i := range el.Fields {
|
|
f.nextShim(&el.Fields[i].FieldElem, id, be)
|
|
}
|
|
case *gen.Array:
|
|
f.nextShim(&el.Els, id, be)
|
|
case *gen.Slice:
|
|
f.nextShim(&el.Els, id, be)
|
|
case *gen.Map:
|
|
f.nextShim(&el.Value, id, be)
|
|
case *gen.Ptr:
|
|
f.nextShim(&el.Value, id, be)
|
|
}
|
|
}
|
|
}
|
|
|
|
// propInline identifies and inlines candidates
|
|
func (f *FileSet) propInline() {
|
|
for name, el := range f.Identities {
|
|
pushstate(name)
|
|
switch el := el.(type) {
|
|
case *gen.Struct:
|
|
for i := range el.Fields {
|
|
f.nextInline(&el.Fields[i].FieldElem, name)
|
|
}
|
|
case *gen.Array:
|
|
f.nextInline(&el.Els, name)
|
|
case *gen.Slice:
|
|
f.nextInline(&el.Els, name)
|
|
case *gen.Map:
|
|
f.nextInline(&el.Value, name)
|
|
case *gen.Ptr:
|
|
f.nextInline(&el.Value, name)
|
|
}
|
|
popstate()
|
|
}
|
|
}
|
|
|
|
const fatalloop = `detected infinite recursion in inlining loop!
|
|
Please file a bug at github.com/tinylib/msgp/issues!
|
|
Thanks!
|
|
`
|
|
|
|
func (f *FileSet) nextInline(ref *gen.Elem, root string) {
|
|
switch el := (*ref).(type) {
|
|
case *gen.BaseElem:
|
|
// ensure that we're not inlining
|
|
// a type into itself
|
|
typ := el.TypeName()
|
|
if el.Value == gen.IDENT && typ != root {
|
|
if node, ok := f.Identities[typ]; ok && node.Complexity() < maxComplex {
|
|
infof("inlining %s\n", typ)
|
|
|
|
// This should never happen; it will cause
|
|
// infinite recursion.
|
|
if node == *ref {
|
|
panic(fatalloop)
|
|
}
|
|
|
|
*ref = node.Copy()
|
|
f.nextInline(ref, node.TypeName())
|
|
} else if !ok && !el.Resolved() {
|
|
// this is the point at which we're sure that
|
|
// we've got a type that isn't a primitive,
|
|
// a library builtin, or a processed type
|
|
warnf("unresolved identifier: %s\n", typ)
|
|
}
|
|
}
|
|
case *gen.Struct:
|
|
for i := range el.Fields {
|
|
f.nextInline(&el.Fields[i].FieldElem, root)
|
|
}
|
|
case *gen.Array:
|
|
f.nextInline(&el.Els, root)
|
|
case *gen.Slice:
|
|
f.nextInline(&el.Els, root)
|
|
case *gen.Map:
|
|
f.nextInline(&el.Value, root)
|
|
case *gen.Ptr:
|
|
f.nextInline(&el.Value, root)
|
|
default:
|
|
panic("bad elem type")
|
|
}
|
|
}
|