this.className = (String) getNameMethod.invoke(antlrGrammarMetadata, NO_ARGS);

            final Method getSuperGrammarMethod = ANTLR_GRAMMAR_CLASS.getMethod("getSuperGrammar", NO_ARG_SIGNATURE);
            getSuperGrammarMethod.setAccessible(true);
            final Object antlrSuperGrammarGrammarMetadata = getSuperGrammarMethod.invoke(antlrGrammarMetadata, NO_ARGS);

        def nullArgs = new MethodInvocation(String.class.getMethod("length"), null)

        expect:
        assertThat(invocation, strictlyEqual(equalInvocation))
        invocation != differentMethod
        invocation != differentArgs
        invocation != nullArgs
        nullArgs != invocation
    }

    def "string representation"() {
        expect:

  // Replace all external uses with block args and update uses.
  llvm::SmallVector<Value, 4> new_args;
  new_args.reserve(extern_values.size());
  Block& block = func_region.front();
  for (Value value : extern_values) {
    auto arg = block.addArgument(value.getType(), loc);
    replaceAllUsesInRegionWith(value, arg, func_region);
    new_args.push_back(arg);
  }

  // Replace yield op with return.

        assertMutable("create(String)");
        return doCreate(name, DefaultTask.class, NO_ARGS, Actions.doNothing());
    }

    @Override
    public Task create(String name, Action<? super Task> configureAction) throws InvalidUserDataException {
        assertMutable("create(String, Action)");
        return doCreate(name, DefaultTask.class, NO_ARGS, configureAction);
    }

    @Override

        analysisSession: KaSession,
        type: KaType,
        symbol: KaClassOrObjectSymbol,
        declarationRenderer: KaDeclarationRenderer,
        printer: PrettyPrinter,
    )

    public object NO_ARGS : KaSuperTypesCallArgumentsRenderer {
        override fun renderSuperTypeArguments(
            analysisSession: KaSession,
            type: KaType,
            symbol: KaClassOrObjectSymbol,

  return new TF_VariableInfo(index, handle.name(), variable);
}

void TF_LockVariableInfos(TF_VariableInfo** vars, int num_vars,
                          TF_Status* status) {
  std::vector<tensorflow::VariableInfo*> variable_ptrs;
  variable_ptrs.reserve(num_vars);
  for (int i = 0; i < num_vars; ++i) {
    variable_ptrs.push_back(&(vars[i]->var_info));
  }

 * </pre>
 *
 * @author Ben Yu
 * @since 12.0
 */
@ElementTypesAreNonnullByDefault
public abstract class AbstractInvocationHandler implements InvocationHandler {

  private static final Object[] NO_ARGS = {};

  /**
   * {@inheritDoc}
   *
   * <ul>
   *   <li>{@code proxy.hashCode()} delegates to {@link AbstractInvocationHandler#hashCode}

 public:
  // Number of input arguments for the compiled computation.
  static constexpr size_t kNumArgs = 5;

  static constexpr size_t kNumResults = 3;

  // Number of variables for the compiled computation.
  static constexpr size_t kNumVariables = 3;

  // Byte size of each argument buffer. There are kNumArgs entries.
  static const ::int64_t ArgSize(::tensorflow::int32 index) {

}

void BM_BuildSignature(::testing::benchmark::State& state) {
  const int n_args = state.range(0);

  NameAttrList fn;
  fn.set_name("afunction");
  for (int i = 0; i < n_args; i++) {
    (*fn.mutable_attr())[absl::StrCat("T", i)].set_type(DT_FLOAT);
  }
  std::vector<XlaCompiler::Argument> args(n_args);
  for (int i = 0; i < n_args; i++) {
    args[i].kind = (((i % 3) == 0) ? XlaCompiler::Argument::kConstant

func.func @main() {
  cf.br ^bb1
^bb1:
  func.return
}

// -----

// CHECK-LABEL: func @no_args
// CHECK-SAME: (%arg0: tensor<!tf_type.resource<tensor<f32>>> {tf.resource_name = "x"})
// CHECK-NOT: "tf.VarHandleOp"
func.func @no_args() {
  %0 = "tf.VarHandleOp"() {container = "", shape = "tfshape$", shared_name = "x"} : () -> tensor<!tf_type.resource<tensor<f32>>>
  func.return
}