Add MappedType.UnionTypeInfos (#670)

* Add code to generate IR (not used).

`buildDirectoryDefinitions` and `findEnumSet` have now been converted to
be callable by `GenerateIR`.

Later PRs will convert ypathgen, Go, and proto generation to use the IR
instead of the Directory map.

* Fix underscore generation

* Simplify IR a bit

* Rename goGenState to GoLangMapper.

This name is exported since it will be accessed by generator.go after
the refactoring is done.

The genFakeRoot parameter is also removed since this property can be
checked through other means, as is done in
https://github.com/openconfig/ygot/tree/ygen-ir-langmapper

* Update IR to Support Go Generation

Various updates to the IR for better supporting Go generation.

* Fix staticcheck

* Convert `GenerateGoCode` to use IR for Code Generation.

* Delete some no-longer used code

* Make newGoLangMapper exported

* Fix comment in ygen/codegen.go

Co-authored-by: Rob Shakir <[email protected]>

* Improve style

* gofmt

* Update comment in ygen/directory.go

Co-authored-by: Rob Shakir <[email protected]>

* Add comments that LangMapper should be idempotent

* Add comment

* Add presence container IR handling (merge conflict)

* Add new Fields to IR to support path API generation

* Remove useless line in ypathgen

* Generate Path API using IR.

* Remove unused code

* Remove YANGNodeDetails.Kind and add clarifying comments

* Remove usage of YANGNodeDetails.Kind

* textual -> text

* rename RootModule -> RootElementModule

* fix name

* Improve doc comments on BelongingModule

* Remove useless line in ypathgen (#656)

* Change name to LeafrefTargetPath

* [backwards-incompatible] Delete enum flags for `proto_generator`

These flags make IR generation more complex (maybe a day or so of work), so I want to remove them now a bit early ahead of v1 release to avoid the throwaway work.

* More accurate enum naming and classification according to namesake type.

Currently for unions it uses the outer-most union for the name and the type classification, but it should rather use the namesake union instead.

* Rename protoGenState to ProtoLangMapper

* Change `IR.Enums` map's key to be a unique key instead of the enum's name.

* Add `MappedType.UnionTypeInfos`

This will be used to store the key to the global enum map in the `IR`.

* Update ygen/genstate.go

Co-authored-by: Rob Shakir <[email protected]>

Co-authored-by: Rob Shakir <[email protected]>

Author: wenovus

ygen/genstate.go

@@ -39,11 +39,11 @@ type MappedType struct {
 	// NativeType is the candidate language-specific type name which is to
 	// be used for the mapped entity.
 	NativeType string
-	// EnumeratedYANGTypeName stores a globally-unique name that can be
-	// used to key into IR.EnumeratedYANGTypes containing all of the
-	// enumeration definitions. This value should be populated when
+	// EnumeratedYANGTypeKey stores a globally-unique key that can be
+	// used to key into IR's EnumeratedYANGTypes map containing all of the
+	// enumeration definitions. This value should only be populated when
 	// IsEnumeratedValue is true.
-	//EnumeratedYANGTypeName string
+	//EnumeratedYANGTypeKey string
 	// UnionTypes is a map, keyed by the generated type name, of the types
 	// specified as valid for a union. The value of the map indicates the
 	// order of the type, since order is important for unions in YANG.
@@ -52,6 +52,9 @@ type MappedType struct {
 	// the generated code from the structs maintains only type validation,
 	// this is not currently a limitation.
 	UnionTypes map[string]int
+	// UnionTypeInfos stores more information about each union subtype that
+	// can be populated if needed during the code generation pass.
+	UnionTypeInfos map[string]MappedUnionSubtype
 	// IsEnumeratedValue specifies whether the NativeType that is returned
 	// is a generated enumerated value. Such entities are reflected as
 	// derived types with constant values, and are hence not represented
@@ -67,6 +70,16 @@ type MappedType struct {
 	DefaultValue *string
 }
 
+// MappedUnionSubtype stores information associated with a union subtype within
+// a MappedType.
+type MappedUnionSubtype struct {
+	// EnumeratedYANGTypeKey stores a globally-unique key that can be
+	// used to key into IR's EnumeratedYANGTypes map containing all of the
+	// enumeration definitions. This value should only be populated when
+	// the union subtype is an enumerated type.
+	//EnumeratedYANGTypeKey string
+}
+
 // IsYgenDefinedGoType returns true if the native type of a MappedType is a Go
 // type that's defined by ygen's generated code.
 func IsYgenDefinedGoType(t *MappedType) bool {

ygen/goelements_test.go

@@ -58,7 +58,13 @@ func TestUnionSubTypes(t *testing.T) {
 		},
 		want: []string{"string"},
 		wantMtypes: map[int]*MappedType{
-			0: {"string", nil, false, goZeroValues["string"], nil},
+			0: {
+				NativeType:        "string",
+				UnionTypes:        nil,
+				IsEnumeratedValue: false,
+				ZeroValue:         goZeroValues["string"],
+				DefaultValue:      nil,
+			},
 		},
 	}, {
 		name: "union of int8, string",
@@ -75,8 +81,20 @@ func TestUnionSubTypes(t *testing.T) {
 		},
 		want: []string{"int8", "string"},
 		wantMtypes: map[int]*MappedType{
-			0: {"int8", nil, false, goZeroValues["int8"], nil},
-			1: {"string", nil, false, goZeroValues["string"], nil},
+			0: {
+				NativeType:        "int8",
+				UnionTypes:        nil,
+				IsEnumeratedValue: false,
+				ZeroValue:         goZeroValues["int8"],
+				DefaultValue:      nil,
+			},
+			1: {
+				NativeType:        "string",
+				UnionTypes:        nil,
+				IsEnumeratedValue: false,
+				ZeroValue:         goZeroValues["string"],
+				DefaultValue:      nil,
+			},
 		},
 	}, {
 		name: "union of unions",
@@ -105,10 +123,34 @@ func TestUnionSubTypes(t *testing.T) {
 		},
 		want: []string{"string", "int32", "uint64", "int16"},
 		wantMtypes: map[int]*MappedType{
-			0: {"string", nil, false, goZeroValues["string"], nil},
-			1: {"int32", nil, false, goZeroValues["int32"], nil},
-			2: {"uint64", nil, false, goZeroValues["uint64"], nil},
-			3: {"int16", nil, false, goZeroValues["int16"], nil},
+			0: {
+				NativeType:        "string",
+				UnionTypes:        nil,
+				IsEnumeratedValue: false,
+				ZeroValue:         goZeroValues["string"],
+				DefaultValue:      nil,
+			},
+			1: {
+				NativeType:        "int32",
+				UnionTypes:        nil,
+				IsEnumeratedValue: false,
+				ZeroValue:         goZeroValues["int32"],
+				DefaultValue:      nil,
+			},
+			2: {
+				NativeType:        "uint64",
+				UnionTypes:        nil,
+				IsEnumeratedValue: false,
+				ZeroValue:         goZeroValues["uint64"],
+				DefaultValue:      nil,
+			},
+			3: {
+				NativeType:        "int16",
+				UnionTypes:        nil,
+				IsEnumeratedValue: false,
+				ZeroValue:         goZeroValues["int16"],
+				DefaultValue:      nil,
+			},
 		},
 	}, {
 		name: "erroneous union without context",
@@ -342,8 +384,20 @@ func TestUnionSubTypes(t *testing.T) {
 		},
 		want: []string{"E_Basemod_Id", "E_Basemod2_Id2"},
 		wantMtypes: map[int]*MappedType{
-			0: {"E_Basemod_Id", nil, true, "0", nil},
-			1: {"E_Basemod2_Id2", nil, true, "0", nil},
+			0: {
+				NativeType:        "E_Basemod_Id",
+				UnionTypes:        nil,
+				IsEnumeratedValue: true,
+				ZeroValue:         "0",
+				DefaultValue:      nil,
+			},
+			1: {
+				NativeType:        "E_Basemod2_Id2",
+				UnionTypes:        nil,
+				IsEnumeratedValue: true,
+				ZeroValue:         "0",
+				DefaultValue:      nil,
+			},
 		},
 	}, {
 		name: "union of single identityref",