Handle aliased types (#406)

Allow for aliased types. By far the cleanest solution is to just use a replace directive.

Fixes #250

Author: klauspost

_generated/def.go

@@ -24,6 +24,18 @@ import (
 
 type Block [32]byte
 
+// test fixed-size struct
+// size compilation
+type Fixed struct {
+	A float64
+	B bool
+}
+
+type AliasedType = Fixed
+type AliasedType2 = *Fixed
+type AliasedType3 = uint64
+type AliasedType4 = *uint64
+
 // tests edge-cases with
 // compiling size compilation.
 type X struct {
@@ -42,13 +54,10 @@ type X struct {
 	ZCBytesMap     map[string][]byte            `msg:",zerocopy"`
 	ZCBytesMapDeep map[string]map[string][]byte `msg:",zerocopy"`
 	CustomBytes    CustomBytes                  `msg:",zerocopy"`
-}
-
-// test fixed-size struct
-// size compilation
-type Fixed struct {
-	A float64
-	B bool
+	Renamed1       AliasedType
+	Renamed2       AliasedType2
+	Renamed3       AliasedType3
+	Renamed4       AliasedType4
 }
 
 type TestType struct {

parse/getast.go

@@ -19,6 +19,7 @@ type FileSet struct {
 	Package       string              // package name
 	Specs         map[string]ast.Expr // type specs in file
 	Identities    map[string]gen.Elem // processed from specs
+	Aliased       map[string]string   // Aliased types.
 	Directives    []string            // raw preprocessor directives
 	Imports       []*ast.ImportSpec   // imports
 	CompactFloats bool                // Use smaller floats when feasible
@@ -121,6 +122,22 @@ func (fs *FileSet) applyDirectives() {
 			}
 		}
 	}
+	// Apply aliases last, so we don't overrule any manually specified replace directives.
+	for _, d := range fs.Aliased {
+		chunks := strings.Split(d, " ")
+		if len(chunks) > 0 {
+			if fn, ok := directives[chunks[0]]; ok {
+				pushstate(chunks[0])
+				err := fn(chunks, fs)
+				if err != nil {
+					warnf("directive error: %s", err)
+				}
+				popstate()
+			} else {
+				newdirs = append(newdirs, d)
+			}
+		}
+	}
 	fs.Directives = newdirs
 }
 
@@ -318,6 +335,15 @@ func (fs *FileSet) getTypeSpecs(f *ast.File) {
 			for _, s := range g.Specs {
 				// for ast.TypeSpecs....
 				if ts, ok := s.(*ast.TypeSpec); ok {
+					// Handle type aliases, by adding a "replace" directive.
+					if ts.Assign != 0 {
+						if fs.Aliased == nil {
+							fs.Aliased = make(map[string]string)
+						}
+						fs.Aliased[ts.Name.Name] = fmt.Sprintf("replace %s with:%s", ts.Name.Name, stringify(ts.Type))
+						continue
+					}
+
 					switch ts.Type.(type) {
 					// this is the list of parse-able
 					// type specs
@@ -589,7 +615,7 @@ func (fs *FileSet) parseExpr(e ast.Expr) gen.Elem {
 		// can be done later, once we've resolved
 		// everything else.
 		if b.Value == gen.IDENT {
-			if _, ok := fs.Specs[e.Name]; !ok {
+			if _, ok := fs.Specs[e.Name]; !ok && fs.Aliased[e.Name] == "" {
 				warnf("possible non-local identifier: %s\n", e.Name)
 			}
 		}