[Blocked] Check unique default before using the value

encoder/generate_test.go

@@ -78,17 +78,19 @@ func loadCases(dir string) ([]Case, error) {
 		if len(a.Files) != 2 {
 			return nil, fmt.Errorf("Malformed test case '%s': Must contain exactly two files (CUE and TS/ERR), but has %d", file, len(a.Files))
 		}
-		if strings.HasSuffix(fi.Name(), "error") {
+
+		fname := strings.TrimSuffix(fi.Name(), filepath.Ext(fi.Name()))
+		if strings.HasSuffix(fname, "error") {
 			cases = append(cases, Case{
 				CaseType: ErrorType,
-				Name:     fi.Name(),
+				Name:     fname,
 				CUE:      string(a.Files[0].Data),
 				ERROR:    strings.TrimSuffix(string(a.Files[1].Data), "\n"),
 			})
 		} else {
 			cases = append(cases, Case{
 				CaseType: TSType,
-				Name:     fi.Name(),
+				Name:     fname,
 				CUE:      string(a.Files[0].Data),
 				TS:       string(a.Files[1].Data),
 			})

encoder/generator.go

@@ -181,13 +181,16 @@ func (g *generator) genType(name string, v cue.Value) {
 
 	tvars["tokens"] = tokens
 
-	d, ok := v.Default()
+	d, ok, err := validateAndGetDefault(v)
+	if err != nil {
+		g.addErr(err)
+	}
+
 	if ok {
 		dStr, err := tsprintField(d)
 		g.addErr(err)
 		tvars["default"] = dStr
 	}
-
 	// TODO comments
 	// TODO maturity marker (@alpha, etc.)
 	g.exec(typeCode, tvars)
@@ -220,7 +223,7 @@ func (g *generator) genEnum(name string, v cue.Value) {
 			g.addErr(err)
 		}
 		pairs = orPairs
-		defaultValue, err = getDefaultValue(v)
+		defaultValue, err = getDefaultEnumValue(v)
 		if err != nil {
 			g.addErr(err)
 		}
@@ -243,8 +246,25 @@ func (g *generator) genEnum(name string, v cue.Value) {
 	g.exec(enumCode, tvars)
 }
 
-func getDefaultValue(v cue.Value) (string, error) {
+func validateAndGetDefault(v cue.Value) (cue.Value, bool, error) {
 	def, ok := v.Default()
+	if ok {
+		label, _ := def.Label()
+		op, dvals := def.Expr()
+		if len(dvals) > 1 && op == cue.OrOp {
+			return def, true, valError(v, "%s has multiple defaults which is not allowed", label)
+		}
+		return def, true, nil
+	}
+	return def, false, nil
+}
+
+func getDefaultEnumValue(v cue.Value) (string, error) {
+	def, ok, err := validateAndGetDefault(v)
+	if err != nil {
+		return "", err
+	}
+
 	if ok {
 		if v.IncompleteKind() == cue.StringKind {
 			dStr, err := tsprintField(def)
@@ -475,7 +495,11 @@ func (g *generator) genInterface(name string, v cue.Value) {
 
 		kv := KV{K: k, V: vstr}
 
-		d, ok := fields.Value().Default()
+		// When default exist but have sevarals, we need to fail
+		d, ok, err := validateAndGetDefault(fields.Value())
+		if err != nil {
+			g.addErr(err)
+		}
 		// [...number] results in [], which is not desired
 		// TODO: There must be a better way to handle this
 		if ok && d.IncompleteKind() != cue.ListKind {

encoder/tests/conflictEnumDef.txtar

@@ -0,0 +1,29 @@
+
+This would be the typical cases we should fail, since Bar is refereced to a type with default
+and we are trying to assign another default
+
+Seems CUE is picking the default before eval it, it seems we can get the reference first and
+check whether default exist there, if yes if the default also exist for the current cue object error out
+
+Or should we just forbidden the disjunction between Enum and other types??
+-- cue --
+package cuetsy
+
+AOrEnum: "foo" | "bar" | *"baz" @cuetsy(kind="enum")
+Foo: {
+  Bar: AOrEnum | *"ohai"
+} @cuetsy(kind="interface")
+
+-- err --
+export enum AOrEnum {
+  Bar = 'bar',
+  Baz = 'baz',
+  Foo = 'foo',
+}
+export const aOrEnumDefault: AOrEnum = AOrEnum.Baz
+export interface Foo {
+  Bar: AOrEnum | 'ohai';
+}
+export const fooDefault: Foo = {
+  Bar: 'ohai',
+}

encoder/tests/conflictInterfaceDeferror.txtar

@@ -0,0 +1,8 @@
+-- cue --
+Foo: {
+  Bar: string | *"ohai"
+  Baz: int | *4 | *7
+} @cuetsy(kind="interface")
+
+-- err --
+Baz has multiple defaults which is not allowed

encoder/tests/conflictTypeDeferror.txtar

@@ -0,0 +1,8 @@
+-- cue --
+AType: "foo" | *"bar" | "baz" @cuetsy(kind="type")
+BType: "foo" | "bar" | *"baz" @cuetsy(kind="type")
+CType: AType | BType @cuetsy(kind="type")
+
+
+-- err --
+CType has multiple defaults which is not allowed