if err != nil {
		t.Fatal(err)
	}
	return s
}

// NewLocal does not deploy a new server, but instead configures Istio
// to allow calls to a local authz server running as a sidecar to the echo
// app.
func NewLocal(ctx resource.Context, ns namespace.Instance) (Server, error) {
	return newLocalKubeServer(ctx, ns)
}

// NewLocalOrFail calls NewLocal and fails if an error occurs.

		base.FatalfAt(pos, "misuse of method type: %v", typ)
	}
	types.CalcSize(typ)

	sym := &types.Sym{
		Name: autotmpname(len(curfn.Dcl)),
		Pkg:  types.LocalPkg,
	}
	name := curfn.NewLocal(pos, sym, typ)
	name.SetEsc(ir.EscNever)
	name.SetUsed(true)
	name.SetAutoTemp(true)

	return name
}

var (
	autotmpnamesmu sync.Mutex
	autotmpnames   []string
)

	if !f.Config.UseFMA {
		return false
	}
	if base.FmaHash == nil {
		return true
	}
	return base.FmaHash.MatchPos(v.Pos, nil)
}

// NewLocal returns a new anonymous local variable of the given type.
func (f *Func) NewLocal(pos src.XPos, typ *types.Type) *ir.Name {
	nn := typecheck.TempAt(pos, f.fe.Func(), typ) // Note: adds new auto to fn.Dcl list
	nn.SetNonMergeable(true)
	return nn
}

				if !used[i] {
					s.nReuse++
					break
				}
			}
			// If there is no unused stack slot, allocate a new one.
			if i == len(locs) {
				s.nAuto++
				locs = append(locs, LocalSlot{N: f.NewLocal(v.Pos, v.Type), Type: v.Type, Off: 0})
				locations[typeKey] = locs
			}
			// Use the stack variable at that index for v.
			loc := locs[i]
			if f.pass.debug > stackDebug {

					if isVolatile(val) {
						for _, c := range volatiles {
							if val == c.src {
								continue copyLoop // already copied
							}
						}

						t := val.Type.Elem()
						tmp := f.NewLocal(w.Pos, t)
						mem = b.NewValue1A(w.Pos, OpVarDef, types.TypeMem, tmp, mem)
						tmpaddr := b.NewValue2A(w.Pos, OpLocalAddr, t.PtrTo(), tmp, sp, mem)
						siz := t.Size()

					// The type of the slot is immaterial - it will not be live across
					// any safepoint. Just use a type big enough to hold any register.
					t := LocalSlot{N: e.s.f.NewLocal(c.Pos, types.Int64), Type: types.Int64}
					// TODO: reuse these slots. They'll need to be erased first.
					e.set(t, vid, x, false, c.Pos)
					if e.s.f.pass.debug > regDebug {

			// stack with a special name, so the debugger can look for it and
			// find the parent frame.
			sym := &types.Sym{Name: ".closureptr", Pkg: types.LocalPkg}
			cloSlot := s.curfn.NewLocal(src.NoXPos, sym, s.f.Config.Types.BytePtr)
			cloSlot.SetUsed(true)
			cloSlot.SetEsc(ir.EscNever)
			cloSlot.SetAddrtaken(true)
			s.f.CloSlot = cloSlot