)

// initStackTemp appends statements to init to initialize the given
// temporary variable to val, and then returns the expression &tmp.
func initStackTemp(init *ir.Nodes, tmp *ir.Name, val ir.Node) *ir.AddrExpr {
	if val != nil && !types.Identical(tmp.Type(), val.Type()) {
		base.Fatalf("bad initial value for %L: %L", tmp, val)
	}
	appendWalkStmt(init, ir.NewAssignStmt(base.Pos, tmp, val))

        urlFilter.addInclude(".*test.*");

        assertEquals(1, urlFilter.cachedIncludeSet.size());
        assertEquals(0, urlFilter.cachedExcludeSet.size());

        final String sessionId = "id1";
        urlFilter.init(sessionId);
        assertEquals(0, urlFilter.cachedIncludeSet.size());
        assertEquals(0, urlFilter.cachedExcludeSet.size());
        assertEquals(1, dataHelper.getIncludeUrlPatternList(sessionId).size());

                    settings.pluginManager.apply("com.gradle.develocity")
                }
            }
        """

        when:
        succeeds "t", "--scan", "--init-script", initScript.absolutePath

        then:
        plugin.assertAutoApplied(output, false)
        outputContains("Applying ${plugin.id} via init script")

func NewLazyRESTMapperLoader(fn func() (RESTMapper, error)) RESTMapper {
	obj := &lazyObject{loader: fn}
	return obj
}

// init lazily loads the mapper and typer, returning an error if initialization has failed.
func (o *lazyObject) init() error {
	o.lock.Lock()
	defer o.lock.Unlock()
	if o.loaded {
		return o.err
	}
	o.mapper, o.err = o.loader()
	o.loaded = true
	return o.err
}

internal class ThreadLocalValue<V : Any>(private val init: () -> V) {
    private val map = ConcurrentHashMap<Long, V>()

    @Suppress("NOTHING_TO_INLINE")
    inline operator fun getValue(thisRef: Any?, property: KProperty<*>): V =
        map.computeIfAbsent(Thread.currentThread().id) {
            init()
        }
}

internal fun <V : Any> threadLocal(init: () -> V): ThreadLocalValue<V> =

// have the appropriate number of names and init exprs. For const
// decls, init is the value spec providing the init exprs; for
// var decls, init is nil (the init exprs are in s in this case).
func (check *Checker) arityMatch(s, init *ast.ValueSpec) {
	l := len(s.Names)
	r := len(s.Values)
	if init != nil {
		r = len(init.Values)
	}

	const code = WrongAssignCount
	switch {
	case init == nil && r == 0:
		// var decl w/o init expr

func main() int { return 1 } // ERROR "func main must have no arguments and no return values" "main redeclared in this block"

func init(int)  {}           // ERROR "func init must have no arguments and no return values"

	}
	if !more {
		panic("traceback truncated after f")
	}
	f, more = iter.Next()
	if f.Function != "test/a.init" || !strings.HasSuffix(f.File, "a.go") || f.Line != 15 {
		panic(fmt.Sprintf("bad init %v\n", f))
	}
	if !more {
		panic("traceback truncated after init")
	}
	f, _ = iter.Next()
	if !strings.HasPrefix(f.Function, "runtime.") {
		panic("runtime. driver missing")
	}

	return 0
}

                                      llvm::ArrayRef<mlir::Type>(outputs));
           });
  py::class_<mlir::OpBuilder>(m, "OpBuilder")
      .def(py::init<mlir::MLIRContext*>())
      .def(py::init<mlir::Region&>())
      .def(py::init<mlir::Operation*>())
      .def(py::init<mlir::Block*, mlir::Block::iterator>())
      .def("getUnknownLoc", &mlir::OpBuilder::getUnknownLoc)
      .def("setInsertionPoint",

// Copyright 2021 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.

package issue48082