fix bug with type checking case/cond branches

This commit fixes a type checking problem where the type checker
was too aggresive in checking all branches of conditional expressions.
Instead, we require that just one branch is clean.  If all the
branches have errors, then we report the errors and the query
fails to compile.

We will later at a strict-mode of type checking that requires
type assertions when needed and all the branches must pass
similar to the relational model.

Fixes #6563

Author: mccanne

compiler/semantic/expr.go

@@ -71,17 +71,31 @@ func (t *translator) expr(e ast.Expr, inType super.Type) (sem.Expr, super.Type)
 	case *ast.CaseExpr:
 		return t.semCaseExpr(e, inType)
 	case *ast.CondExpr:
+		var errlocs [][]errloc
 		cond, condType := t.expr(e.Cond, inType)
+		t.checker.boolean(e.Cond, condType)
+		t.checker.pushErrs()
 		thenExpr, thenType := t.expr(e.Then, inType)
+		if errs := t.checker.popErrs(); len(errs) != 0 {
+			errlocs = append(errlocs, errs)
+		}
 		var elseExpr sem.Expr
 		var elseType super.Type
 		if e.Else != nil {
+			t.checker.pushErrs()
 			elseExpr, elseType = t.expr(e.Else, inType)
+			if errs := t.checker.popErrs(); len(errs) != 0 {
+				errlocs = append(errlocs, errs)
+			}
 		} else {
 			elseExpr = sem.NewStringError(e, "missing")
 			elseType = t.checker.unknown
 		}
-		t.checker.boolean(e.Cond, condType)
+		if len(errlocs) == 2 {
+			for _, errs := range errlocs {
+				t.checker.keepErrs(errs)
+			}
+		}
 		return &sem.CondExpr{
 			Node: e,
 			Cond: cond,
@@ -664,6 +678,7 @@ func (t *translator) semCaseExpr(c *ast.CaseExpr, inType super.Type) (sem.Expr,
 		elseType = t.checker.unknown
 	}
 	types := []super.Type{elseType}
+	var thenErrs [][]errloc
 	for _, when := range slices.Backward(c.Whens) {
 		cond, condType := t.expr(when.Cond, inType)
 		if e != nil {
@@ -672,15 +687,27 @@ func (t *translator) semCaseExpr(c *ast.CaseExpr, inType super.Type) (sem.Expr,
 		} else {
 			t.checker.boolean(when.Cond, condType)
 		}
+		t.checker.pushErrs()
 		then, thenType := t.expr(when.Then, inType)
 		out = &sem.CondExpr{
 			Node: c,
 			Cond: cond,
 			Then: then,
 			Else: out,
 		}
+		if errs := t.checker.popErrs(); len(errs) != 0 {
+			thenErrs = append(thenErrs, errs)
+		}
 		types = append(types, thenType)
 	}
+	if len(thenErrs) == len(c.Whens) {
+		// All the paths have errors so report them.
+		// If at least one path is ok, then we deem the overall expression valid
+		// an do not report any errors.
+		for _, errs := range thenErrs {
+			t.checker.keepErrs(errs)
+		}
+	}
 	return out, t.checker.fuse(types)
 }
 

compiler/semantic/ztests/checker-case.yaml

@@ -0,0 +1,42 @@
+script: |
+  super -s -I walk.spq in.sup
+  ! super -s -I fail.spq in.sup
+
+inputs:
+  - name: walk.spq
+    data: |
+      fn walk(node, visit):
+        case kind(node)
+        when "array" then
+          [unnest node | walk(this, visit)]
+        when "record" then
+          unflatten([unnest flatten(node) | {key,value:walk(value, visit)}])
+        when "union" then
+          walk(under(node), visit)
+        else visit(node)
+        end
+      fn addOne(node): case typeof(node) when <int64> then node+1 else node end
+      values walk(this, &addOne)
+  - name: fail.spq
+    data: |
+      values
+        case typeof(this)
+        when <string> then this+1
+        else this+2
+        end
+  - name: in.sup
+    data: |
+      {n:1}
+
+outputs:
+  - name: stdout
+    data: |
+      {n:2}
+  - name: stderr
+    data: |
+      type mismatch: {n:int64} + int64 in fail.spq at line 4, column 8:
+        else this+2
+             ~~~~~~
+      type mismatch: {n:int64} + int64 in fail.spq at line 3, column 22:
+        when <string> then this+1
+                           ~~~~~~

compiler/semantic/ztests/checker-cond-fail.yaml

@@ -0,0 +1,17 @@
+script: |
+  ! super -s -c "values has(n) ? this+1 : this+2" in.sup
+
+inputs:
+  - name: in.sup
+    data: |
+      {n:1}
+
+outputs:
+  - name: stderr
+    data: |
+      type mismatch: {n:int64} + int64 at line 1, column 17:
+      values has(n) ? this+1 : this+2
+                      ~~~~~~
+      type mismatch: {n:int64} + int64 at line 1, column 26:
+      values has(n) ? this+1 : this+2
+                               ~~~~~~