// device cluster ops.
  for (auto func : module.getOps<func::FuncOp>()) {
    for (auto user : symbol_map.getUsers(func)) {
      // Populate caller-callee map.
      if (func::FuncOp caller = user->getParentOfType<func::FuncOp>())
        caller_callee_map[caller].insert(func);
      // Initialize function worklist with functions refrerenced in device
      // cluster.
      if (auto cluster = user->getParentOfType<tf_device::ClusterOp>()) {

			log.Fatalf("os.WriteFile: %s\n", err)
		}
	})
	log.Printf("output directory: %s\n", outDir)
}

func walkCodes(f func(string, *ast.ValueSpec)) {
	fset := token.NewFileSet()
	file, err := parser.ParseFile(fset, "codes.go", nil, parser.ParseComments)
	if err != nil {
		log.Fatalf("ParseFile failed: %s", err)
	}
	conf := Config{Importer: importer.Default()}
	info := &Info{
		Types: make(map[ast.Expr]TypeAndValue),

func (s *Server) CreateCertificate(ctx context.Context, request *pb.IstioCertificateRequest) (
	*pb.IstioCertificateResponse, error,
) {
	s.monitoring.CSR.Increment()
	caller, err := security.Authenticate(ctx, s.Authenticators)
	if caller == nil || err != nil {
		s.monitoring.AuthnError.Increment()
		return nil, status.Error(codes.Unauthenticated, "request authenticate failure")
	}

  return true;
}

bool ParseFile(flatbuffers::Parser *parser, const std::string &filename,
               const std::string &contents) {
  std::vector<const char *> include_directories;
  auto local_include_directory = flatbuffers::StripFileName(filename);
  include_directories.push_back(local_include_directory.c_str());
  include_directories.push_back(nullptr);
  if (!parser->Parse(contents.c_str(), include_directories.data(),

class ErrorHandlingNotationParserTest extends Specification {
    def NotationParser<String, String> target = Mock()
    def parser = new ErrorHandlingNotationParser<String, String>("a thing", "<broken>", false, target)

    def "reports unable to parse null"() {
        when:
        parser.parseNotation(null)

        then:
        UnsupportedNotationException e = thrown()

        CommandLineParser parser = new CommandLineParser();
        new InitialPropertiesConverter().configure(parser);
        new BuildLayoutConverter().configure(parser);
        converter.configure(parser);
        ParsedCommandLine parsedCommandLine;
        try {
            parsedCommandLine = parser.parse(arguments != null ? arguments : Collections.emptyList());

        }

        NotationParser<N, T> parser = new NotationConverterToNotationParserAdapter<>(notationConverter);
        if (notationType.isAssignableFrom(resultingType.getTargetType()) && implicitConverters) {
            parser = new JustReturningParser<>(resultingType.getTargetType(), parser);
        }
        return parser;
    }

    private static class LazyDisplayName<T> implements Describable {

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.List;

public class SnappyCommonsPacker implements Packer {
    private final Packer delegate;

    public SnappyCommonsPacker(Packer delegate) {
        this.delegate = delegate;
    }

    @Override
    public void pack(List<DataSource> inputs, DataTarget output) throws IOException {

To parse the text associated with a doc comment (after removing comment markers),
use a [Parser]:

	var p comment.Parser
	doc := p.Parse(text)

The result is a [*Doc].
To reformat it as a doc comment, HTML, Markdown, or plain text,
use a [Printer]:

	var pr comment.Printer
	os.Stdout.Write(pr.Text(doc))

The [Parser] and [Printer] types are structs whose fields can be
modified to customize the operations.

The files are in [txtar format](https://pkg.go.dev/golang.org/x/tools/txtar).
Consider this example:

	-- input --
	Hello.
	-- gofmt --
	Hello.
	-- html --
	<p>Hello.
	-- markdown --
	Hello.
	-- text --
	Hello.

Each `-- name --` line introduces a new file with the given name.
The file named “input” must be first and contains the input to