}

	sig.params = NewTuple(params...)
	sig.results = NewTuple(results...)
	sig.variadic = variadic
}

// collectParams declares the parameters of list in scope and returns the corresponding
// variable list.
func (check *Checker) collectParams(scope *Scope, list []*syntax.Field, variadicOk bool, scopePos syntax.Pos) (params []*Var, variadic bool) {
	if list == nil {
		return
	}

	var named, anonymous bool

	}

	sig.params = NewTuple(params...)
	sig.results = NewTuple(results...)
	sig.variadic = variadic
}

// collectParams declares the parameters of list in scope and returns the corresponding
// variable list.
func (check *Checker) collectParams(scope *Scope, list *ast.FieldList, variadicOk bool, scopePos token.Pos) (params []*Var, variadic bool) {
	if list == nil {
		return
	}

	var named, anonymous bool

  }];

  let arguments = (ins
    TFTensorType:$max_iterations,
    Variadic<TFTensorType>:$tensor_list_or_flow_in,
    Variadic<TFTensorType>:$invariant_args,
    FlatSymbolRefAttr:$body_fn,
    I32Attr:$num_tensor_list_or_flow_in
  );

  let results = (outs
     Variadic<TFTensorType>:$result
  );

// license that can be found in the LICENSE file.

// Issue 5231: method values lose their variadic property.

package p

type T int

func (t T) NotVariadic(s []int) int {
	return int(t) + s[0]
}

func (t T) Variadic(s ...int) int {
	return int(t) + s[0]
}

type I interface {
	NotVariadic(s []int) int
	Variadic(s ...int) int
}

func F() {
	var t T
	var p *T = &t
	var i I = p

    Execute $a_true_fn with $args if $cond is true; otherwise, %b_false_fn is
    executed.
  }];

  let arguments = (ins
    I1:$cond,
    Variadic<AnyType>:$args,
    SymbolRefAttr:$a_true_fn,
    SymbolRefAttr:$b_false_fn
  );

  let results = (outs
    Variadic<AnyType>:$results
  );

  let assemblyFormat = [{
    $cond $a_true_fn $b_false_fn `(` $args `)` attr-dict `:` `(` type($args) `)` `->` `(` type($results) `)`

        (MHLO_CompositeOp:$composite
          (variadic $inputs),
          ConstantStrAttr<StrAttr, "aten.gelu.default">, $attrs, $_, $_),
        (TFL_GeluOp $inputs, ConstBoolAttrFalse),
        [(IsStrCompositeAttribute<"approximate", "none"> $attrs)]>;

def LegalizeCompositeApproximateAtenGELU : Pat<
        (MHLO_CompositeOp:$composite
          (variadic $inputs),

  }];

  let arguments = (ins
    TF_Tensor:$max_iterations,
    Variadic<TF_Tensor>:$tensor_list_or_flow_in,
    Variadic<TF_Tensor>:$invariant_args,
    FlatSymbolRefAttr:$body_fn,
    I32Attr:$num_tensor_list_or_flow_in
  );

  let results = (outs
     Variadic<TF_Tensor>:$result
  );

      input fallback tensors.

    results: the converted corert tensorhandles.
  }];

  let arguments = (ins
    Variadic<TFTensorType>:$args,
    StrAttr:$device
  );

  let results = (outs
    Variadic<CoreRT_TensorHandleType>:$results
  );

  let assemblyFormat = "operands attr-dict `:` `(` type($args) `)` `->` `(` type($results) `)`";
}

    StrAttr:$device,
    FlatSymbolRefAttr:$func,
    Variadic<AnyType>);

  let results = (outs
    Variadic<AnyType>:$results
  );
}

def TfDevice_ParallelExecuteOp : TfDevice_Op<"parallel_execute",
    [SingleBlockImplicitTerminator<"ReturnOp">]> {
  let description = [{
    ParallelExecute op concurrently executes variadic number of regions. Regions

    TF_StrTensor:$names,
    Variadic<TF_StrTensor>:$sparse_keys,
    Variadic<TF_StrTensor>:$dense_keys,
    Variadic<TensorOf<[TF_Float32, TF_Int64, TF_Str]>>:$dense_defaults,

    TF_ShapeAttrArray:$dense_shapes
  );

  let results = (outs
    Variadic<TF_Int64Tensor>:$sparse_indices,                           // len(sparse_types)