[fromString(), "command.execute(null, (File) null)", "", ""],
            [fromString(), "command.execute((String[]) null, (File) null)", "", ""],
            // type-wrapped arguments
            [fromString(), "command.execute((String[]) ['FOOBAR=foobar'], null)", "", "foobar"],
            [fromString(), "command.execute((List) ['FOOBAR=foobar'], null)", "", "foobar"],

        !op->hasTrait<OpTrait::IsTerminator>() && !isMemoryEffectFree(op)) {
      return WalkResult::interrupt();
    }
    // op has implict arguments not listed in operands.
    // Fact: if every op's operands are defined in the same block as op,
    //       then no operation has implicit arugments (constant doesn't count).
    for (auto operand : op->getOperands()) {
      if (mlir::dyn_cast_or_null<BlockArgument>(operand)) continue;

            [fromStringArray(), "Runtime.getRuntime().exec(command)", "", ""],
            // Spread calls
            [fromString(), "Runtime.getRuntime().exec(*[command])", "", ""],
            // type-wrapped arguments
            [fromGroovyString(), "Runtime.getRuntime().exec(command as String)", "", ""],
            [fromObjectList(), "Runtime.getRuntime().exec(command as String[])", "", ""],
            // Null-safe calls

# The prototypes are marked by lines beginning with "//sys"
# and read like func declarations if //sys is replaced by func, but:
#	* The parameter lists must give a name for each argument.
#	  This includes return parameters.
#	* The parameter lists must give a type for each argument:
#	  the (x, y, z int) shorthand is not allowed.
#	* If the return parameter is an error number, it must be named errno.

//   2) The `tf_saved_model` dialect requires that the arguments with
//   `tf_saved_model.index_path` attributes should precede those with
//   `tf_saved_model.bound_input` attributes. The init function of type
//   `kTfSavedModelInitializerRestoreType` usually has an argument with
//   `tf_saved_model.index_path`, whereas the init function of type
//   `kTfSavedModelInitializerInitType` may have arguments with

            [fromString(), "ProcessGroovyMethods.execute(command, null, (File) null)", "", ""],
            [fromString(), "ProcessGroovyMethods.execute(command, (String[]) null, (File) null)", "", ""],
            // type-wrapped arguments
            [fromGroovyString(), "ProcessGroovyMethods.execute(command as String, null, null)", "", ""],
            [fromString(), "ProcessGroovyMethods.execute(command, (String[]) ['FOOBAR=foobar'], null)", "", "foobar"],

// like go build or go fix.
type Command struct {
	// Run runs the command.
	// The args are the arguments after the command name.
	Run func(ctx context.Context, cmd *Command, args []string)

	// UsageLine is the one-line usage message.
	// The words between "go" and the first flag or argument in the line are taken to be the command name.
	UsageLine string

	// Short is the short description shown in the 'go help' output.

			}
			goto nextCheck
		default:
			return nil, fmt.Errorf("sql: converting argument %s type: %w", describeNamedValue(nv), err)
		}
	}

	// Check the length of arguments after conversion to allow for omitted
	// arguments.
	if want != -1 && len(nvargs) != want {
		return nil, fmt.Errorf("sql: expected %d arguments, got %d", want, len(nvargs))
	}

	return nvargs, nil
}

  return result;
}

// Removes the unused resource arguments, and the return values that forward the
// removed arguments. If old_to_new_arg_indices is provided, it will store the
// new argument index that corresponds to each original index (-1 means it is
// removed). If remaining_resource_data_types is provided, it will store the
// data types of the remaining resource arguments, where the indices are after
// removing unused ones.

value (argument) or a function or method call, possibly with multiple arguments:

	Argument
		The result is the value of evaluating the argument.
	.Method [Argument...]
		The method can be alone or the last element of a chain but,
		unlike methods in the middle of a chain, it can take arguments.
		The result is the value of calling the method with the
		arguments:
			dot.Method(Argument1, etc.)