#include "tensorflow/compiler/mlir/lite/experimental/tac/tac_importer_exporter.h"

namespace mlir {
namespace TFL {
namespace tac {
// TAC Importer for TFLite.
// This import to MLIR from tflite file or MLIR
class TfLiteImporter : public mlir::TFL::tac::TacImporter {
 public:
  // Options for configuring the importer.
  struct Options {
    std::string file_name;
    // Whether the input file is an MLIR not tflite file.
    bool input_mlir = false;

stdout '^example.net/m v0.2.0 '
stdout '^example.net/m/p v1.0.0 '

-- go.mod --
module example.net/importer

go 1.16

require (
	example.net/m v0.1.0
)

replace (
	example.net/m v0.1.0 => ./m1
	example.net/m v0.2.0 => ./m2
	example.net/m/p v1.0.0 => ./p0
)
-- importer.go --
package importer
import _ "example.net/m/p"
-- m1/go.mod --
module example.net/m

go 1.16
-- m1/p/p.go --
package p

	// error found.
	Error func(err error)

	// An importer is used to import packages referred to from
	// import declarations.
	// If the installed importer implements ImporterFrom, the type
	// checker calls ImportFrom instead of Import.
	// The type checker reports an error if an importer is needed
	// but none was installed.
	Importer Importer

	// If Sizes != nil, it provides the sizing functions for package unsafe.

package facts

import (
	"go/types"

	"golang.org/x/tools/internal/aliases"
)

// importMap computes the import map for a package by traversing the
// entire exported API each of its imports.
//
// This is a workaround for the fact that we cannot access the map used
// internally by the types.Importer returned by go/importer. The entries

		_ = obj.Pkg()
	}
}
`
	// like src0, but also imports go/importer
	const src1 = `
package main

import (
	"go/types"
	_ "go/importer"
)

func main() {
	var info types.Info
	for _, obj := range info.Uses {
		_ = obj.Pkg()
	}
}
`
	// like src1 but with different import order
	// (used to fail with this issue)
	const src2 = `
package main

into a proper TF2 execution mode. This hides that boilerplate.
"""

import tempfile
from absl import app
from absl import flags
from absl import logging
import tensorflow.compat.v1 as tf

from tensorflow.python import pywrap_mlir  # pylint: disable=g-direct-tensorflow-import

# Use /tmp to make debugging the tests easier (see README.md)

`,
	} {
		files = append(files, mustParse(fset, src))
	}

	// Type-check a package consisting of these files.
	// Type information for the imported "fmt" package
	// comes from $GOROOT/pkg/$GOOS_$GOOARCH/fmt.a.
	conf := types.Config{Importer: importer.Default()}
	pkg, err := conf.Check("temperature", fset, files, nil)
	if err != nil {
		log.Fatal(err)
	}

	// Print the tree of scopes.

package types_test

import (
	"errors"
	"fmt"
	"go/importer"
	"go/types"
	"strings"
	"testing"
)

func checkMono(t *testing.T, body string) error {
	src := "package x; import `unsafe`; var _ unsafe.Pointer;\n" + body

	var buf strings.Builder
	conf := types.Config{
		Error:    func(err error) { fmt.Fprintln(&buf, err) },
		Importer: importer.Default(),
	}
	typecheck(src, &conf, nil)

// Copyright 2016 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Test cases for issue #15838, and related failures.
// Make sure the importer correctly sets up nodes for
// label decls, goto, continue, break, and fallthrough
// statements.

		switch gotypesalias.Value() {
		case "", "1":
			if strings.Contains(src, "interface{R}.Read") {
				continue
			}
		}

		files = append(files, file)
	}

	conf := Config{Importer: importer.Default()}
	pkg, err := conf.Check("p", fset, files, nil)
	if err != nil {
		t.Fatal(err)
	}

	for _, file := range files {
		for _, group := range file.Comments {