NegationBuild(builder Builder)
}

// Expr raw expression
type Expr struct {
	SQL                string
	Vars               []interface{}
	WithoutParentheses bool
}

// Build build raw expression
func (expr Expr) Build(builder Builder) {
	var (
		afterParenthesis bool
		idx              int
	)

	for _, v := range []byte(expr.SQL) {
		if v == '?' && len(expr.Vars) > idx {

			expr:         `isIP("2001:db8::68")`,
			expectResult: trueVal,
		},
		{
			name:         "isIP invalid ipv4",
			expr:         `isIP("2001:db8:::68")`,
			expectResult: falseVal,
		},
		{
			name:         "ip.isCanonical valid ipv6",
			expr:         `ip.isCanonical("2001:db8::68")`,
			expectResult: trueVal,
		},
		{
			name:         "ip.isCanonical non-canonical ipv6",

const _ /* ERROR "missing init expr for _" */
const _ = 1, 2 /* ERROR "extra init expr 2" */

const _ /* ERROR "missing init expr for _" */ int
const _ int = 1, 2 /* ERROR "extra init expr 2" */

const (
	_ /* ERROR "missing init expr for _" */
	_ = 1, 2 /* ERROR "extra init expr 2" */

	_ /* ERROR "missing init expr for _" */ int
	_ int = 1, 2 /* ERROR "extra init expr 2" */
)

const (
	_ = 1
	_

        data class Failed(val errors: Collection<DocumentError>) : ExprConversion
    }


    private
    fun exprToValue(expr: Expr): ExprConversion = when (expr) {
        is Literal<*> -> ExprConversion.Converted(literalNode(expr))
        is FunctionCall -> run {
            val errors = mutableListOf<DocumentError>()

                && value.getClass().getName().startsWith("java.lang."));
    }

    private String stripTokens(String expr) {
        if (expr.startsWith("${") && (expr.indexOf('}') == expr.length() - 1)) {
            expr = expr.substring(2, expr.length() - 1);
        }
        return expr;
    }

    @Override
    public File alignToBaseDirectory(File file) {

		}
	}

	var buf bytes.Buffer

	var expr string
	if x.expr != nil {
		expr = ExprString(x.expr)
	} else {
		switch x.mode {
		case builtin:
			expr = predeclaredFuncs[x.id].name
		case typexpr:
			expr = TypeString(x.typ, qf)
		case constant_:
			expr = x.val.String()
		}
	}

	// <expr> (
	if expr != "" {
		buf.WriteString(expr)
		buf.WriteString(" (")
	}

}


sealed interface FunctionArgument : LanguageTreeElement {
    sealed interface ValueArgument : FunctionArgument {
        val expr: Expr
    }

    data class Positional(override val expr: Expr, override val sourceData: SourceData) : ValueArgument
    data class Named(val name: String, override val expr: Expr, override val sourceData: SourceData) : ValueArgument

               },
               "expr": "sum by (pod) (\n  container_memory_working_set_bytes{container=\"discovery\", pod=~\"istiod-.*\"}\n)",
               "legendFormat": "Container ({{pod}})"
            },
            {
               "datasource": {
                  "type": "prometheus",
                  "uid": "$datasource"
               },

	wrapInParentheses := false

	for idx, expr := range exprs {
		if idx > 0 {
			if v, ok := expr.(OrConditions); ok && len(v.Exprs) == 1 {
				builder.WriteString(OrWithSpace)
			} else {
				builder.WriteString(joinCond)
			}
		}

		if len(exprs) > 1 {
			switch v := expr.(type) {
			case OrConditions:
				if len(v.Exprs) == 1 {
					if e, ok := v.Exprs[0].(Expr); ok {
						sql := strings.ToUpper(e.SQL)

    internal.istio.io/parents: Gateway/gateway/slctr-expr-notin-yes.istio-system
  creationTimestamp: null
  name: gateway-istio-autogenerated-k8s-gateway-slctr-expr-notin-yes
  namespace: istio-system
spec:
  servers:
  - hosts:
    - default/*.slctr-expr-notin-yes.example
    - group-namespace1/*.slctr-expr-notin-yes.example
    - group-namespace2/*.slctr-expr-notin-yes.example