// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

type myMap map[string] int;

func f() myMap {
	m := make(map[string] int);
	return m
}

func main() {
	m := make(myMap);
	mp := &m;

	{
		x, ok := m["key"];
		_, _ = x, ok;
	}
	{
		x, ok := (*mp)["key"];
		_, _ = x, ok;
	}
	{

// uses initializers of blank variables inside closures.

package main

var Test = func() {
	var mymap = map[string]string{"a": "b"}

	var innerTest = func() {
		// Used to crash trying to compile this line as
		// part of init() (funcdepth mismatch).
		var _, x = mymap["a"]
		println(x)
	}
	innerTest()
}

var Test2 = func() {
	// The following initializer should not be part of init()

    }

    def "circular evaluation of map property is detected"() {
        buildFile """
            def myMap = objects.mapProperty(String, String)
            def myLazyProv = provider {
                myMap.getting("foo").getOrElse("not_there")
            }
            myMap.put("bar", myLazyProv.map { "barbar" })
            myLazyProv.get()

            tasks.register("verify") {}
        """

// license that can be found in the LICENSE file.

// This package is a lightly modified version of the mmap code
// in github.com/google/codesearch/index.

// The mmap package provides an abstraction for memory mapping files
// on different platforms.
package mmap

import (
	"os"
)

// Data is mmap'ed read-only data from a file.
// The backing file is never closed, so Data

// license that can be found in the LICENSE file.

// This package is a lightly modified version of the mmap code
// in github.com/google/codesearch/index.

// The mmap package provides an abstraction for memory mapping files
// on different platforms.
package mmap

import (
	"os"
)

// The backing file is never closed, so Data
// remains valid for the lifetime of the process.

package runtime

import "unsafe"

// mmap calls the mmap system call. It is implemented in assembly.
// We only pass the lower 32 bits of file offset to the
// assembly routine; the higher bits (if required), should be provided
// by the assembly routine as 0.
// The err result is an OS error code such as ENOMEM.
func mmap(addr unsafe.Pointer, n uintptr, prot, flags, fd int32, off uint32) (p unsafe.Pointer, err int)

import _ "unsafe"

// When using cgo, call the C library for mmap, so that we call into
// any sanitizer interceptors. This supports using the memory
// sanitizer with Go programs. The memory sanitizer only applies to
// C/C++ code; this permits that code to see the Go code as normal
// program addresses that have been initialized.

// To support interceptors that look for both mmap and munmap,
// also call the C library for munmap.

	}

	// Mmap should fail at a half page into the buffer.
	_, err = runtime.Mmap(unsafe.Pointer(uintptr(b)+ps/2), ps, 0, runtime.MAP_ANON|runtime.MAP_PRIVATE|runtime.MAP_FIXED, -1, 0)
	if err == 0 {
		t.Errorf("Mmap should have failed with half-page alignment %d, but succeeded: %v", ps/2, err)
	}

	// Mmap should succeed at a full page into the buffer.

//go:linkname _cgo_munmap _cgo_munmap
var _cgo_munmap unsafe.Pointer

// mmap is used to route the mmap system call through C code when using cgo, to
// support sanitizer interceptors. Don't allow stack splits, since this function
// (used by sysAlloc) is called in a lot of low-level parts of the runtime and
// callers often assume it won't acquire any locks.
//
//go:nosplit

//go:build unix && (!solaris || go1.20)

package mmap

import (
	"fmt"
	"io/fs"
	"os"
	"syscall"
)

func mmapFile(f *os.File, _ *Data) (Data, error) {
	st, err := f.Stat()
	if err != nil {
		return Data{}, err
	}
	size := st.Size()
	pagesize := int64(os.Getpagesize())
	if int64(int(size+(pagesize-1))) != size+(pagesize-1) {
		return Data{}, fmt.Errorf("%s: too large for mmap", f.Name())
	}
	n := int(size)