automatically convert between common protobuf time/durations

ast.go

@@ -14,6 +14,14 @@ func astAssign(left, right ast.Expr) ast.Stmt {
 	}
 }
 
+func astAssignMulti(left, right []ast.Expr) ast.Stmt {
+	return &ast.AssignStmt{
+		Lhs: left,
+		Tok: token.ASSIGN,
+		Rhs: right,
+	}
+}
+
 func astDeclare(varName string, varType ast.Expr) ast.Stmt {
 	return &ast.DeclStmt{Decl: &ast.GenDecl{
 		Tok: token.VAR,
@@ -157,6 +165,7 @@ func newAssignStmtSlice(
 	convertFuncName string,
 	direct bool,
 	convert bool,
+	special specialAssignmentAttributes,
 ) ast.Stmt {
 	return &ast.BlockStmt{List: []ast.Stmt{
 		// <left> = make(<leftType>, len(<right>))
@@ -198,6 +207,7 @@ func newAssignStmtSlice(
 					convertFuncName,
 					direct,
 					convert,
+					special,
 				),
 			}},
 		},
@@ -213,6 +223,7 @@ func newAssignStmtMap(
 	convertFuncName string,
 	direct bool,
 	convert bool,
+	special specialAssignmentAttributes,
 ) ast.Stmt {
 	return &ast.BlockStmt{List: []ast.Stmt{
 		// <left> = make(<leftType>, len(<right>))
@@ -254,6 +265,7 @@ func newAssignStmtMap(
 					convertFuncName,
 					direct,
 					convert,
+					special,
 				),
 				newAssignStmtStructsAndPointers(
 					&ast.IndexExpr{
@@ -277,16 +289,55 @@ func newAssignStmt(
 	convertFuncName string,
 	direct bool,
 	convert bool,
+	special specialAssignmentAttributes,
 ) ast.Stmt {
-	if direct && convert {
+	switch {
+	case direct && convert:
 		panic("direct and convert cannot both be set")
+	case direct && !special.IsZero():
+		panic("direct and special cannot both be set")
+	case convert && !special.IsZero():
+		panic("convert and special cannot both be set")
 	}
+
 	if convert {
 		right = &ast.CallExpr{
 			Fun:  leftType,
 			Args: []ast.Expr{right},
 		}
 	}
+
+	switch {
+	case special.ProtobufDuration && special.ProtobufDirection == DirTo:
+		// struct-to-pointer
+		return newAssignStmtUserFunc(
+			left,
+			right,
+			"ptypes.DurationProto",
+		)
+	case special.ProtobufDuration && special.ProtobufDirection == DirFrom:
+		// pointer-to-struct
+		return newAssignMultiStmtUserFunc(
+			[]ast.Expr{left, &ast.Ident{Name: "_"}},
+			[]ast.Expr{right},
+			"ptypes.Duration",
+		)
+	case special.ProtobufTimestamp && special.ProtobufDirection == DirTo:
+		// struct-to-pointer
+		return newAssignMultiStmtUserFunc(
+			[]ast.Expr{left, &ast.Ident{Name: "_"}},
+			[]ast.Expr{right},
+			"ptypes.TimestampProto",
+		)
+	case special.ProtobufTimestamp && special.ProtobufDirection == DirFrom:
+		// pointer-to-struct
+		return newAssignMultiStmtUserFunc(
+			[]ast.Expr{left, &ast.Ident{Name: "_"}},
+			[]ast.Expr{right},
+			"ptypes.Timestamp",
+		)
+	}
+
 	if convertFuncName != "" && !direct && !convert {
 		return newAssignStmtConvertible(
 			left,
@@ -320,6 +371,24 @@ func newAssignStmtUserFunc(
 	})
 }
 
+func newAssignMultiStmtUserFunc(
+	left []ast.Expr,
+	right []ast.Expr,
+	userFuncName string,
+) ast.Stmt {
+	// No special handling for pointers here if someone used the mog
+	// annotations themselves. The assumption is the user knows what
+	// they're doing.
+
+	// <left1>, <left2>, ... = <funcName>(<right1>, <right2>, ...)
+	return astAssignMulti(left, []ast.Expr{
+		&ast.CallExpr{
+			Fun:  &ast.Ident{Name: userFuncName},
+			Args: right,
+		},
+	})
+}
+
 // TODO: do the pointer stuff with go/types instead like everything else now?
 func newAssignStmtStructsAndPointers(
 	left ast.Expr,

config.go

@@ -80,6 +80,15 @@ type Direction string
 
 func (d Direction) String() string { return string(d) }
 
+func (d Direction) Reverse() Direction {
+	if d == DirFrom {
+		return DirTo
+	} else if d == DirTo {
+		return DirFrom
+	}
+	return d
+}
+
 const (
 	DirFrom Direction = "From"
 	DirTo   Direction = "To"

generate.go

@@ -165,9 +165,9 @@ func generateConversion(cfg structConfig, t targetStruct, imports *imports) (gen
 		}
 
 		// the assignmentKind is <target> := <source> so target==LHS source==RHS
-		rawKind, ok := computeAssignment(field.Type(), sourceField.SourceType)
-		if !ok {
-			assignErrFn(nil)
+		rawKind, err := computeAssignment(field.Type(), sourceField.SourceType, imports)
+		if err != nil {
+			assignErrFn(err)
 			continue
 		}
 
@@ -181,6 +181,7 @@ func generateConversion(cfg structConfig, t targetStruct, imports *imports) (gen
 				sourceField.ConvertFuncName(DirTo),
 				kind.Direct,
 				kind.Convert,
+				kind.Special,
 			))
 			from.Body.List = append(from.Body.List, newAssignStmt(
 				srcExpr,
@@ -190,6 +191,7 @@ func generateConversion(cfg structConfig, t targetStruct, imports *imports) (gen
 				sourceField.ConvertFuncName(DirFrom),
 				kind.Direct,
 				kind.Convert,
+				kind.Special.ReverseDirection(),
 			))
 		case *sliceAssignmentKind:
 			targetElemTypeElem := typeToExpr(kind.LeftElem, imports, true)
@@ -213,6 +215,7 @@ func generateConversion(cfg structConfig, t targetStruct, imports *imports) (gen
 				sourceField.ConvertFuncName(DirTo),
 				kind.ElemDirect,
 				kind.ElemConvert,
+				kind.ElemSpecial,
 			))
 			from.Body.List = append(from.Body.List, newAssignStmtSlice(
 				srcExpr,
@@ -223,6 +226,7 @@ func generateConversion(cfg structConfig, t targetStruct, imports *imports) (gen
 				sourceField.ConvertFuncName(DirFrom),
 				kind.ElemDirect,
 				kind.ElemConvert,
+				kind.ElemSpecial.ReverseDirection(),
 			))
 		case *mapAssignmentKind:
 			targetKeyTypeElem := typeToExpr(kind.LeftKey, imports, true)
@@ -258,6 +262,7 @@ func generateConversion(cfg structConfig, t targetStruct, imports *imports) (gen
 				sourceField.ConvertFuncName(DirTo),
 				kind.ElemDirect,
 				kind.ElemConvert,
+				kind.ElemSpecial,
 			))
 			from.Body.List = append(from.Body.List, newAssignStmtMap(
 				srcExpr,
@@ -268,6 +273,7 @@ func generateConversion(cfg structConfig, t targetStruct, imports *imports) (gen
 				sourceField.ConvertFuncName(DirFrom),
 				kind.ElemDirect,
 				kind.ElemConvert,
+				kind.ElemSpecial.ReverseDirection(),
 			))
 		}
 	}

internal/e2e/core/cluster_node.go

@@ -1,6 +1,10 @@
 package core
 
-import "github.com/hashicorp/mog/internal/e2e/core/inner"
+import (
+	"time"
+
+	"github.com/hashicorp/mog/internal/e2e/core/inner"
+)
 
 type Label string
 
@@ -45,10 +49,15 @@ type ClusterNode struct {
 	M7 map[string]Workload
 	M8 map[string]*Workload
 
-	// S1 Workload  // for testing struct-to-struct for slices
-	// S2 *Workload // for testing ptr-to-ptr for slices
-	// S3 Workload  // for testing ptr-to-struct for slices
-	// S4 *Workload // for testing struct-to-ptr for slices
+	// T1 time.Time // for testing struct-to-struct for time
+	// T2 *time.Time // for testing ptr-to-ptr for time
+	T3 time.Time // for testing ptr-to-struct for time
+	// T4 *time.Time // for testing struct-to-ptr for time
+
+	// D1 time.Duration // for testing struct-to-struct for duration
+	// D2 *time.Duration // for testing ptr-to-ptr for duration
+	D3 time.Duration // for testing ptr-to-struct for duration
+	// D4 *time.Duration // for testing struct-to-ptr for duration
 }
 
 type StringSlice []string

internal/e2e/go.mod

@@ -0,0 +1,5 @@
+module github.com/hashicorp/mog/internal/e2e
+
+go 1.14
+
+require github.com/golang/protobuf v1.3.5

internal/e2e/go.sum

@@ -0,0 +1,2 @@
+github.com/golang/protobuf v1.3.5 h1:F768QJ1E9tib+q5Sc8MkdJi1RxLTbRcTf8LJV56aRls=
+github.com/golang/protobuf v1.3.5/go.mod h1:6O5/vntMXwX2lRkT1hjjk0nAC1IDOTvTlVgjlRvqsdk=

internal/e2e/sourcepkg/node.go

@@ -1,6 +1,9 @@
 package sourcepkg
 
 import (
+	"github.com/golang/protobuf/ptypes/duration"
+	"github.com/golang/protobuf/ptypes/timestamp"
+
 	"github.com/hashicorp/mog/internal/e2e/core"
 	"github.com/hashicorp/mog/internal/e2e/core/inner"
 )
@@ -56,10 +59,15 @@ type Node struct {
 	M7 map[string]*Workload
 	M8 map[string]Workload
 
-	// S1 Workload  // for testing struct-to-struct for slices
-	// S2 *Workload // for testing ptr-to-ptr for slices
-	// S3 *Workload // for testing ptr-to-struct for slices
-	// S4 Workload  // for testing struct-to-ptr for slices
+	// T1 timestamp.Timestamp  // for testing struct-to-struct for time
+	// T2 *timestamp.Timestamp // for testing ptr-to-ptr for time
+	T3 *timestamp.Timestamp // for testing ptr-to-struct for time
+	// T4 timestamp.Timestamp  // for testing struct-to-ptr for time
+
+	// D1 duration.Duration  // for testing struct-to-struct for duration
+	// D2 *duration.Duration // for testing ptr-to-ptr for duration
+	D3 *duration.Duration // for testing ptr-to-struct for duration
+	// D4 duration.Duration  // for testing struct-to-ptr for duration
 }
 
 type StringSlice []string

load.go

@@ -53,10 +53,11 @@ type handlePkgLoadErr func(pkg *packages.Package) error
 
 // loadSourceStructs scans the provided package for struct definitions that
 // have mog annotations.
-func loadSourceStructs(path string, tags string, handleErr handlePkgLoadErr) (sourcePkg, error) {
+func loadSourceStructs(path string, workDir string, tags string, handleErr handlePkgLoadErr) (sourcePkg, error) {
 	p := sourcePkg{Structs: map[string]structDecl{}}
 	cfg := &packages.Config{
 		Mode: modeLoadAll,
+		Dir:  workDir,
 	}
 	if tags == "" {
 		tags = os.Getenv("GOTAGS")
@@ -66,7 +67,11 @@ func loadSourceStructs(path string, tags string, handleErr handlePkgLoadErr) (so
 	}
 
 	{
-		fi, err := os.Stat(path)
+		fsPath := path
+		if workDir != "" {
+			fsPath = filepath.Join(workDir, path)
+		}
+		fi, err := os.Stat(fsPath)
 		if err != nil {
 			return p, err
 		}
@@ -180,6 +185,7 @@ var modeLoadAll = packages.NeedName |
 	packages.NeedFiles |
 	packages.NeedCompiledGoFiles |
 	packages.NeedImports |
+	packages.NeedModule |
 	packages.NeedDeps |
 	packages.NeedTypes |
 	packages.NeedSyntax |
@@ -254,10 +260,11 @@ type targetStruct struct {
 	Fields []*types.Var
 }
 
-func loadTargetStructs(names []string, tags string) (map[string]targetPkg, error) {
+func loadTargetStructs(names []string, workDir string, tags string) (map[string]targetPkg, error) {
 	mode := packages.NeedTypes | packages.NeedTypesInfo | packages.NeedName
 	cfg := &packages.Config{
 		Mode: mode,
+		Dir:  workDir,
 	}
 	if tags == "" {
 		tags = os.Getenv("GOTAGS")

load_test.go

@@ -10,7 +10,7 @@ import (
 )
 
 func BenchmarkSourceStructs(b *testing.B) {
-	actual, err := loadSourceStructs("./internal/sourcepkg", "", packageLoadErrors)
+	actual, err := loadSourceStructs("./internal/sourcepkg", "", "", packageLoadErrors)
 	require.NoError(b, err)
 	require.Equal(b, []string{"GroupedSample", "Sample"}, actual.StructNames())
 	_, ok := actual.Structs["Sample"]
@@ -24,7 +24,7 @@ func BenchmarkSourceStructs(b *testing.B) {
 // TODO: test non-built-in types
 // TODO: test types from other packages
 func BenchmarkLoadTargetStructs(b *testing.B) {
-	actual, err := loadTargetStructs([]string{"./internal/targetpkgone", "./internal/targetpkgtwo"}, "")
+	actual, err := loadTargetStructs([]string{"./internal/targetpkgone", "./internal/targetpkgtwo"}, "", "")
 	assert.NilError(b, err)
 
 	expected := map[string]targetPkg{

main.go

@@ -32,6 +32,7 @@ func run(args []string) error {
 
 type options struct {
 	source                  string
+	moduleWorkDir           string
 	ignorePackageLoadErrors bool
 	tags                    string
 }
@@ -54,7 +55,8 @@ func setupFlags(name string) (*flag.FlagSet, *options) {
 	// TODO: make this a positional arg, set a Usage func to document it
 	flags.StringVar(&opts.source, "source", ".", "package path for source structs")
 
-	// TODO: make this a positional arg, set a Usage func to document it
+	flags.StringVar(&opts.moduleWorkDir, "modworkdir", "", "module working directory to run from")
+
 	flags.StringVar(&opts.tags, "tags", ".", "build tags to be passed when parsing the packages")
 
 	flags.BoolVar(&opts.ignorePackageLoadErrors, "ignore-package-load-errors", false,
@@ -67,7 +69,7 @@ func runMog(opts options) error {
 		return fmt.Errorf("missing required source package")
 	}
 
-	sources, err := loadSourceStructs(opts.source, opts.tags, opts.handlePackageLoadErrors)
+	sources, err := loadSourceStructs(opts.source, opts.moduleWorkDir, opts.tags, opts.handlePackageLoadErrors)
 	if err != nil {
 		return fmt.Errorf("failed to load source from %s: %w", opts.source, err)
 	}
@@ -82,7 +84,7 @@ func runMog(opts options) error {
 		return nil
 	}
 
-	targets, err := loadTargetStructs(targetPackages(cfg.Structs), opts.tags)
+	targets, err := loadTargetStructs(targetPackages(cfg.Structs), opts.moduleWorkDir, opts.tags)
 	if err != nil {
 		return fmt.Errorf("failed to load targets: %w", err)
 	}