github.com/amarpal/go-tools@v0.0.0-20240422043104-40142f59f616/go/ir/lvalue.go

// Copyright 2013 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 ir

// lvalues are the union of addressable expressions and map-index
// expressions.

import (
	"go/ast"
	"go/types"
)

// An lvalue represents an assignable location that may appear on the
// left-hand side of an assignment.  This is a generalization of a
// pointer to permit updates to elements of maps.
type lvalue interface {
	store(fn *Function, v Value, source ast.Node) // stores v into the location
	load(fn *Function, source ast.Node) Value     // loads the contents of the location
	address(fn *Function) Value                   // address of the location
	typ() types.Type                              // returns the type of the location
}

// An address is an lvalue represented by a true pointer.
type address struct {
	addr Value
	expr ast.Expr // source syntax of the value (not address) [debug mode]
}

func (a *address) load(fn *Function, source ast.Node) Value {
	return emitLoad(fn, a.addr, source)
}

func (a *address) store(fn *Function, v Value, source ast.Node) {
	store := emitStore(fn, a.addr, v, source)
	if a.expr != nil {
		// store.Val is v, converted for assignability.
		emitDebugRef(fn, a.expr, store.Val, false)
	}
}

func (a *address) address(fn *Function) Value {
	if a.expr != nil {
		emitDebugRef(fn, a.expr, a.addr, true)
	}
	return a.addr
}

func (a *address) typ() types.Type {
	return deref(a.addr.Type())
}

type compositeElement struct {
	cv   *CompositeValue
	idx  int
	t    types.Type
	expr ast.Expr
}

func (ce *compositeElement) load(fn *Function, source ast.Node) Value {
	panic("not implemented")
}

func (ce *compositeElement) store(fn *Function, v Value, source ast.Node) {
	v = emitConv(fn, v, ce.t, source)
	ce.cv.Values[ce.idx] = v
	if ce.expr != nil {
		// store.Val is v, converted for assignability.
		emitDebugRef(fn, ce.expr, v, false)
	}
}

func (ce *compositeElement) address(fn *Function) Value {
	panic("not implemented")
}

func (ce *compositeElement) typ() types.Type {
	return ce.t
}

// An element is an lvalue represented by m[k], the location of an
// element of a map.  These locations are not addressable
// since pointers cannot be formed from them, but they do support
// load() and store().
type element struct {
	m, k Value      // map
	t    types.Type // map element type
}

func (e *element) load(fn *Function, source ast.Node) Value {
	l := &MapLookup{
		X:     e.m,
		Index: e.k,
	}
	l.setType(e.t)
	return fn.emit(l, source)
}

func (e *element) store(fn *Function, v Value, source ast.Node) {
	up := &MapUpdate{
		Map:   e.m,
		Key:   e.k,
		Value: emitConv(fn, v, e.t, source),
	}
	fn.emit(up, source)
}

func (e *element) address(fn *Function) Value {
	panic("map elements are not addressable")
}

func (e *element) typ() types.Type {
	return e.t
}

// A lazyAddress is an lvalue whose address is the result of an instruction.
// These work like an *address except a new address.address() Value
// is created on each load, store and address call.
// A lazyAddress can be used to control when a side effect (nil pointer
// dereference, index out of bounds) of using a location happens.
type lazyAddress struct {
	addr func(fn *Function) Value // emit to fn the computation of the address
	t    types.Type               // type of the location
	expr ast.Expr                 // source syntax of the value (not address) [debug mode]
}

func (l *lazyAddress) load(fn *Function, source ast.Node) Value {
	load := emitLoad(fn, l.addr(fn), source)
	return load
}

func (l *lazyAddress) store(fn *Function, v Value, source ast.Node) {
	store := emitStore(fn, l.addr(fn), v, source)
	if l.expr != nil {
		// store.Val is v, converted for assignability.
		emitDebugRef(fn, l.expr, store.Val, false)
	}
}

func (l *lazyAddress) address(fn *Function) Value {
	addr := l.addr(fn)
	if l.expr != nil {
		emitDebugRef(fn, l.expr, addr, true)
	}
	return addr
}

func (l *lazyAddress) typ() types.Type { return l.t }

// A blank is a dummy variable whose name is "_".
// It is not reified: loads are illegal and stores are ignored.
type blank struct{}

func (bl blank) load(fn *Function, source ast.Node) Value {
	panic("blank.load is illegal")
}

func (bl blank) store(fn *Function, v Value, source ast.Node) {
	s := &BlankStore{
		Val: v,
	}
	fn.emit(s, source)
}

func (bl blank) address(fn *Function) Value {
	panic("blank var is not addressable")
}

func (bl blank) typ() types.Type {
	// This should be the type of the blank Ident; the typechecker
	// doesn't provide this yet, but fortunately, we don't need it
	// yet either.
	panic("blank.typ is unimplemented")
}