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)
	if buf.Len() == 0 {

`,
	} {
		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.

// RUN: flatbuffer_translate -mlir-to-tflite-flatbuffer %s -o - | flatbuffer_translate --tflite-flatbuffer-to-mlir - -o - | FileCheck %s
// This only test the exporter and importer are working without min/max quantization parameters.

func.func @main(tensor<40x37xf32>, tensor<40x37xf32>) -> tensor<40x40xf32> {
^bb0(%arg0: tensor<40x37xf32>, %arg1: tensor<40x37xf32>):
  %cst = arith.constant dense<1.0> : tensor<40xf32>

// 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 {

		paths = append(paths, spath)
	}

	paths = append(paths, inst.LibPaths...)

	return
}

// Return an importer that searches incpaths followed by the gcc installation's
// built-in search paths and the current directory.
func (inst *GccgoInstallation) GetImporter(incpaths []string, initmap map[*types.Package]InitData) Importer {
	return GetImporter(append(append(incpaths, inst.SearchPaths()...), "."), initmap)

# SavedModel importer FileCheck tests.

## Debugging tests

While debugging tests, the following commands are handy.

Run FileCheck test:

```
bazel run :foo.py.test
```

Run just the Python file and look at the output:

```
bazel run :foo
```

Generate saved model to inspect proto:

```
bazel run :foo -- --save_model_path=/tmp/my.saved_model
# Inspect /tmp/my.saved_model/saved_model.pb
```

		if fileMap[fname] {
			files = append(files, f)
		}
	}

	// Call go/types to analyze the runtime package.
	var info types.Info
	info.Types = map[ast.Expr]types.TypeAndValue{}
	conf := types.Config{Importer: importer.Default()}
	_, err = conf.Check("runtime", fset, files, &info)
	if err != nil {
		t.Fatalf("typechecking runtime failed: %v", err)
	}

	// Analyze all atomic.*64 callsites.

//
// 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
// in this map are the packages and objects that may be relevant to the
// current analysis unit.
//
// Packages in the map that are only indirectly imported may be
// incomplete (!pkg.Complete()).
//
// This function scales very poorly with packages' transitive object

NOTE: You can open the samples inside an IDE using the https://www.jetbrains.com/help/idea/gradle.html#gradle_import_project_start[IntelliJ native importer] or https://projects.eclipse.org/projects/tools.buildship[Eclipse Buildship].

This sample shows how to create a plugin with a task that accepts arguments.
The plugin is packaged via an included build.

====
include::sample[dir="kotlin",files="build.gradle.kts[];settings.gradle.kts[]"]