Method semCaseExpr

compiler/semantic/expr.go:680–728

(c *ast.CaseExpr, inType super.Type)

}

func (t *translator) semCaseExpr(c *ast.CaseExpr, inType super.Type) (sem.Expr, super.Type) {
	e, exprType := t.exprNullable(c.Expr, inType)
	var out sem.Expr
	var elseType super.Type
	if c.Else != nil {
		out, elseType = t.expr(c.Else, inType)
	} else if t.scope.sql != nil {
		out = &sem.PrimitiveExpr{Node: c, Value: "null"}
		elseType = super.TypeNull
	} else if e != nil {
		out = sem.NewStructuredError(c, "case: no clause matched and no else provided", e)
		elseType = t.checker.unknown
	} else {
		out = sem.NewStringError(c, "case: no clause matched and no else provided")
		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 {
			cond = sem.NewBinaryExpr(c, "==", e, cond)
			t.checker.comparison(exprType, condType)
		} 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)
}

func (t *translator) semCall(call *ast.CallExpr, inType super.Type) (sem.Expr, super.Type) {
	if e, typ := t.maybeConvertAgg(call, inType); e != nil {