},
          "expr": "go_memstats_heap_alloc_bytes{app=\"istiod\"}",
          "format": "time_series",
          "hide": true,
          "intervalFactor": 2,
          "legendFormat": "heap alloc",
          "refId": "D"
        },
        {
          "datasource": {
            "type": "prometheus",
            "uid": "${datasource}"
          },

    lateinit var codeAnalyzer: CodeAnalyzer
    lateinit var errorCollector: ErrorCollector

    override fun doResolveExpression(context: AnalysisContext, expr: Expr): ObjectOrigin? =
        expressionResolver.doResolveExpression(context, expr)

    override fun analyzeStatementsInProgramOrder(context: AnalysisContext, elements: List<DataStatement>) {
        codeAnalyzer.analyzeStatementsInProgramOrder(context, elements)

      },
      "pluginVersion": "10.1.5",
      "targets": [
        {
          "datasource": {
            "type": "prometheus",
            "uid": "${datasource}"
          },
          "expr": "round(sum(irate(istio_requests_total{reporter=~\"$qrep\",destination_workload_namespace=~\"$namespace\",destination_workload=~\"$workload\"}[5m])), 0.001)",
          "format": "time_series",
          "intervalFactor": 1,

	SliceExpr struct {
		X      Expr      // expression
		Lbrack token.Pos // position of "["
		Low    Expr      // begin of slice range; or nil
		High   Expr      // end of slice range; or nil
		Max    Expr      // maximum capacity of slice; or nil
		Slice3 bool      // true if 3-index slice (2 colons present)
		Rbrack token.Pos // position of "]"
	}

	// A TypeAssertExpr node represents an expression followed by a
	// type assertion.

			r := r.(*ir.TypeAssertExpr)
			r.X = o.expr(r.X, nil)
		case ir.ODYNAMICDOTTYPE2:
			r := r.(*ir.DynamicTypeAssertExpr)
			r.X = o.expr(r.X, nil)
			r.RType = o.expr(r.RType, nil)
			r.ITab = o.expr(r.ITab, nil)
		case ir.ORECV:
			r := r.(*ir.UnaryExpr)
			r.X = o.expr(r.X, nil)
		case ir.OINDEXMAP:
			r := r.(*ir.IndexExpr)
			r.X = o.expr(r.X, nil)
			r.Index = o.expr(r.Index, nil)

               },
               "expr": "sum by (pod) (\n  rate(\n    istio_tcp_connections_opened_total{pod=~\"ztunnel-.*\"}\n  [$__rate_interval])\n)",
               "legendFormat": "Opened ({{pod}})"
            },
            {
               "datasource": {
                  "type": "prometheus",
                  "uid": "$datasource"
               },

      "targets": [
        {
          "datasource": {
            "type": "prometheus",
            "uid": "${DS_PROMETHEUS}"
          },
          "exemplar": true,
          "expr": "time() - max(minio_node_process_starttime_seconds{job=~\"$scrape_jobs\"})",
          "format": "time_series",
          "instant": true,
          "interval": "",
          "intervalFactor": 1,

            "uid": "${datasource}"
          },
          "expr": "avg(envoy_wasm_envoy_wasm_runtime_null_active)",
          "interval": "",
          "legendFormat": "native",
          "refId": "A"
        },
        {
          "datasource": {
            "type": "prometheus",
            "uid": "${datasource}"
          },
          "expr": "avg(envoy_wasm_envoy_wasm_runtime_v8_active)",
          "interval": "",

// extractName splits the expression x into (name, expr) if syntactically
// x can be written as name expr. The split only happens if expr is a type
// element (per the isTypeElem predicate) or if force is set.
// If x is just a name, the result is (name, nil). If the split succeeds,
// the result is (name, expr). Otherwise the result is (nil, x).
// Examples:
//
//	x           force    name    expr
//	------------------------------------

			return
		}

		// rhs must be of the form: expr.(type) and expr must be an ordinary interface
		expr, _ := rhs.(*ast.TypeAssertExpr)
		if expr == nil || expr.Type != nil {
			check.error(s, InvalidSyntaxTree, "incorrect form of type switch guard")
			return
		}
		var x operand
		check.expr(nil, &x, expr.X)
		if x.mode == invalid {
			return
		}