wartank/vendor/modernc.org/gc/v3/value.go

// Copyright 2022 The Gc 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 gc // modernc.org/gc/v3

import (
	"go/constant"
	"math"
)

var (
	_ Expression = (*BasicLitNode)(nil)
	_ Expression = (*BinaryExpressionNode)(nil)
	_ Expression = (*CompositeLitNode)(nil)
	_ Expression = (*ConversionNode)(nil)
	_ Expression = (*FunctionLitNode)(nil)
	_ Expression = (*KeyedElementNode)(nil)
	_ Expression = (*LiteralValueNode)(nil)
	_ Expression = (*MethodExprNode)(nil)
	_ Expression = (*OperandNameNode)(nil)
	_ Expression = (*OperandNode)(nil)
	_ Expression = (*OperandQualifiedNameNode)(nil)
	_ Expression = (*ParenthesizedExpressionNode)(nil)
	_ Expression = (*PrimaryExprNode)(nil)
	_ Expression = (*UnaryExprNode)(nil)
	_ Expression = (*ValueExpression)(nil)

	falseVal = constant.MakeBool(false)
	trueVal  = constant.MakeBool(true)
	unknown  = constant.MakeUnknown()
)

func known(v constant.Value) bool { return v != nil && v.Kind() != constant.Unknown }

type valueCache struct {
	v constant.Value
}

func (n *valueCache) Value() constant.Value {
	if n.v != nil {
		return n.v
	}

	return unknown
}

func (n *valueCache) setValue(v constant.Value) constant.Value {
	n.v = v
	return v
}

type valuer interface {
	Value() constant.Value
}

type Expression interface {
	Node
	checkExpr(c *ctx) Expression
	clone() Expression
	typer
	valuer
}

type ValueExpression struct {
	Node
	typeCache
	valueCache
}

func (n *ValueExpression) checkExpr(c *ctx) Expression {
	panic(todo("%v: %T %s", n.Position(), n, n.Source(false)))
}

func (n *ValueExpression) clone() Expression {
	panic(todo("%v: %T %s", n.Position(), n, n.Source(false)))
}

func (n *BasicLitNode) Type() Type {
	switch n.Ch() {
	case CHAR:
		return n.ctx.int32
	case INT:
		return n.ctx.untypedInt
	case FLOAT:
		return n.ctx.untypedFloat
	case STRING:
		return n.ctx.untypedString
	default:
		panic(todo("%v: %T %s %v", n.Position(), n, n.Source(false), n.Ch()))
	}
}

func (n *BasicLitNode) Value() constant.Value {
	return constant.MakeFromLiteral(n.Src(), n.Ch(), 0)
}

func (n *BasicLitNode) checkExpr(c *ctx) Expression {
	n.ctx = c
	if !known(n.Value()) {
		c.err(n, "invalid literal: %s", n.Source(false))
	}
	return n
}

func (n *BasicLitNode) clone() Expression {
	panic(todo("%v: %T %s", n.Position(), n, n.Source(false)))
}

func (n *OperandNameNode) Type() Type {
	panic(todo("%v: %T %s", n.Position(), n, n.Source(false)))
}

func (n *OperandNameNode) Value() constant.Value {
	panic(todo("%v: %T %s", n.Position(), n, n.Source(false)))
}

func (n *OperandNameNode) checkExpr(c *ctx) Expression {
	in, named := n.LexicalScope().lookup(n.Name)
	switch x := named.n.(type) {
	case *ConstSpecNode:
		switch in.kind {
		case UniverseScope:
			switch n.Name.Src() {
			case "iota":
				if c.iota < 0 {
					panic(todo("%v: %T %s", n.Position(), x, n.Source(false)))
				}

				r := &ValueExpression{Node: x}
				r.t = c.untypedInt
				r.v = constant.MakeInt64(c.iota)
				return r
			default:
				panic(todo("%v: %T %s", n.Position(), x, n.Source(false)))
			}
		default:
			return x.Expression
		}
	default:
		panic(todo("%v: %T %s", n.Position(), x, n.Source(false)))
	}
}

func (n *OperandNameNode) clone() Expression {
	panic(todo("%v: %T %s", n.Position(), n, n.Source(false)))
}

func (n *ParenthesizedExpressionNode) Type() Type {
	panic(todo("%v: %T %s", n.Position(), n, n.Source(false)))
}

func (n *ParenthesizedExpressionNode) Value() constant.Value {
	panic(todo("%v: %T %s", n.Position(), n, n.Source(false)))
}

func (n *ParenthesizedExpressionNode) checkExpr(c *ctx) Expression {
	return n.Expression.checkExpr(c)
}

func (n *ParenthesizedExpressionNode) clone() Expression {
	panic(todo("%v: %T %s", n.Position(), n, n.Source(false)))
}

func (n *LiteralValueNode) Type() Type {
	panic(todo("%v: %T %s", n.Position(), n, n.Source(false)))
}

func (n *LiteralValueNode) Value() constant.Value {
	panic(todo("%v: %T %s", n.Position(), n, n.Source(false)))
}

func (n *LiteralValueNode) checkExpr(c *ctx) Expression {
	panic(todo("%v: %T %s", n.Position(), n, n.Source(false)))
}

func (n *LiteralValueNode) clone() Expression {
	panic(todo("%v: %T %s", n.Position(), n, n.Source(false)))
}

func (n *KeyedElementNode) Type() Type {
	panic(todo("%v: %T %s", n.Position(), n, n.Source(false)))
}

func (n *KeyedElementNode) Value() constant.Value {
	panic(todo("%v: %T %s", n.Position(), n, n.Source(false)))
}

func (n *KeyedElementNode) checkExpr(c *ctx) Expression {
	panic(todo("%v: %T %s", n.Position(), n, n.Source(false)))
}

func (n *KeyedElementNode) clone() Expression {
	panic(todo("%v: %T %s", n.Position(), n, n.Source(false)))
}

func (n *CompositeLitNode) Type() Type {
	panic(todo("%v: %T %s", n.Position(), n, n.Source(false)))
}

func (n *CompositeLitNode) Value() constant.Value {
	panic(todo("%v: %T %s", n.Position(), n, n.Source(false)))
}

func (n *CompositeLitNode) checkExpr(c *ctx) Expression {
	if n == nil {
		return nil
	}

	if !n.enter(c, n) {
		return n
	}

	t := n.setType(c.checkType(n.LiteralType))
	n.LiteralValue.check(c, t)
	return n
}

func (n *CompositeLitNode) clone() Expression {
	panic(todo("%v: %T %s", n.Position(), n, n.Source(false)))
}

func (n *LiteralValueNode) check(c *ctx, t Type) {
	if n == nil {
		return
	}

	switch t.Kind() {
	case Array:
		n.checkArray(c, t.(*ArrayTypeNode))
	default:
		panic(todo("%v: %T %s %v", n.Position(), n, n.Source(false), t.Kind()))
	}
}

func (n *LiteralValueNode) checkArray(c *ctx, t *ArrayTypeNode) {
	panic(todo("%v: %T %s %s", n.Position(), n, t, n.Source(false)))
}

func (n *FunctionLitNode) Type() Type {
	panic(todo("%v: %T %s", n.Position(), n, n.Source(false)))
}

func (n *FunctionLitNode) Value() constant.Value {
	panic(todo("%v: %T %s", n.Position(), n, n.Source(false)))
}

func (n *FunctionLitNode) checkExpr(c *ctx) Expression {
	panic(todo("%v: %T %s", n.Position(), n, n.Source(false)))
}

func (n *FunctionLitNode) clone() Expression {
	panic(todo("%v: %T %s", n.Position(), n, n.Source(false)))
}

func (n *OperandNode) Type() Type {
	panic(todo("%v: %T %s", n.Position(), n, n.Source(false)))
}

func (n *OperandNode) Value() constant.Value {
	panic(todo("%v: %T %s", n.Position(), n, n.Source(false)))
}

func (n *OperandNode) checkExpr(c *ctx) Expression {
	panic(todo("%v: %T %s", n.Position(), n, n.Source(false)))
}

func (n *OperandNode) clone() Expression {
	panic(todo("%v: %T %s", n.Position(), n, n.Source(false)))
}

func (n *OperandQualifiedNameNode) Type() Type {
	panic(todo("%v: %T %s", n.Position(), n, n.Source(false)))
}

func (n *OperandQualifiedNameNode) Value() constant.Value {
	panic(todo("%v: %T %s", n.Position(), n, n.Source(false)))
}

func (n *OperandQualifiedNameNode) checkExpr(c *ctx) Expression {
	panic(todo("%v: %T %s", n.Position(), n, n.Source(false)))
}

func (n *OperandQualifiedNameNode) clone() Expression {
	panic(todo("%v: %T %s", n.Position(), n, n.Source(false)))
}

func (n *ConversionNode) Type() Type {
	return n.TypeNode
}

func (n *ConversionNode) checkExpr(c *ctx) Expression {
	t := n.TypeNode.check(c)
	n.Expression = n.Expression.checkExpr(c)
	v := n.Expression.Value()
	n.v = c.convertValue(n.Expression, v, t)
	return n
}

func (n *ConversionNode) clone() Expression {
	panic(todo("%v: %T %s", n.Position(), n, n.Source(false)))
}

func (n *MethodExprNode) Type() Type {
	panic(todo("%v: %T %s", n.Position(), n, n.Source(false)))
}

func (n *MethodExprNode) Value() constant.Value {
	panic(todo("%v: %T %s", n.Position(), n, n.Source(false)))
}

func (n *MethodExprNode) checkExpr(c *ctx) Expression {
	panic(todo("%v: %T %s", n.Position(), n, n.Source(false)))
}

func (n *MethodExprNode) clone() Expression {
	panic(todo("%v: %T %s", n.Position(), n, n.Source(false)))
}

func (n *PrimaryExprNode) Type() Type {
	panic(todo("%v: %T %s", n.Position(), n, n.Source(false)))
}

func (n *PrimaryExprNode) Value() constant.Value {
	panic(todo("%v: %T %s", n.Position(), n, n.Source(false)))
}

func (n *PrimaryExprNode) checkExpr(c *ctx) Expression {
	switch x := n.PrimaryExpr.(type) {
	case *OperandNameNode:
		_, named := x.LexicalScope().lookup(x.Name)
		switch y := named.n.(type) {
		case *TypeDefNode:
			switch z := n.Postfix.(type) {
			case *ArgumentsNode:
				cnv := &ConversionNode{
					TypeNode: &TypeNameNode{
						Name:          x.Name,
						lexicalScoper: x.lexicalScoper,
					},
					LPAREN:     z.LPAREN,
					Expression: z.Expression,
					RPAREN:     z.RPAREN,
				}
				return cnv.checkExpr(c)
			default:
				panic(todo("%v: %T %s", n.Position(), z, n.Source(false)))
			}
		default:
			panic(todo("%v: %T %s", n.Position(), y, n.Source(false)))
		}
	default:
		panic(todo("%v: %T %s", n.Position(), x, n.Source(false)))
	}

	n.PrimaryExpr = n.PrimaryExpr.checkExpr(c)
	switch x := n.Postfix.(type) {
	default:
		panic(todo("%v: %T %s", n.Position(), x, n.Source(false)))
	}
}

func (n *PrimaryExprNode) clone() Expression {
	panic(todo("%v: %T %s", n.Position(), n, n.Source(false)))
}

func (n *BinaryExpressionNode) checkExpr(c *ctx) (r Expression) {
	if n == nil {
		return nil
	}

	if n.typeCache.Type() != Invalid {
		return n
	}

	n.LHS = n.LHS.checkExpr(c)
	n.RHS = n.RHS.checkExpr(c)
	lv := n.LHS.Value()
	lt := n.LHS.Type()
	rv := n.RHS.Value()
	rt := n.RHS.Type()

	defer func() {
		if known(lv) && known(rv) && r != nil && !known(r.Value()) {
			c.err(n.Op, "operation value not determined: %v %s %v", lv, n.Op.Src(), rv)
		}
	}()

	switch n.Op.Ch() {
	case SHL, SHR:
		var u uint64
		var uOk bool
		n.t = lt
		// The right operand in a shift expression must have integer type or be an
		// untyped constant representable by a value of type uint.
		switch {
		case isIntegerType(rt):
			// ok
		case known(rv):
			if isAnyArithmeticType(rt) {
				rv = c.convertValue(n.RHS, rv, c.cfg.uint)
				if known(rv) {
					u, uOk = constant.Uint64Val(rv)
				}
				break
			}

			c.err(n.Op, "TODO %v", n.Op.Src())
			return n
		default:
			panic(todo("%v: %T %s", n.Position(), n, n.Source(false)))
			return n
		}

		// If the left operand of a non-constant shift expression is an untyped
		// constant, it is first implicitly converted to the type it would assume if
		// the shift expression were replaced by its left operand alone.
		switch {
		case known(lv) && !known(rv):
			panic(todo("%v: %T %s", n.Position(), n, n.Source(false)))
			// c.err(n.Op, "TODO %v", n.Op.Ch.str())
			// return n
		case known(lv) && known(rv):
			if !uOk {
				panic(todo(""))
			}

			n.t = lt
			n.v = constant.Shift(lv, n.Op.Ch(), uint(u))
		default:
			trc("", known(lv), known(rv), u, uOk)
			panic(todo("%v: %T %s", n.Position(), n, n.Source(false)))
			// n.t = lt
			// n.v = constant.BinaryOp(lv, n.Op.Ch(), rv)
		}
	case ADD, SUB, MUL, QUO, REM:
		if !isAnyArithmeticType(lt) || !isAnyArithmeticType(rt) {
			c.err(n.Op, "TODO %v %v", lt, rt)
			break
		}

		// For other binary operators, the operand types must be identical unless the
		// operation involves shifts or untyped constants.
		//
		// Except for shift operations, if one operand is an untyped constant and the
		// other operand is not, the constant is implicitly converted to the type of
		// the other operand.
		switch {
		case isAnyUntypedType(lt) && isAnyUntypedType(rt):
			n.v = constant.BinaryOp(lv, n.Op.Ch(), rv)
			switch n.v.Kind() {
			case constant.Int:
				n.t = c.untypedInt
			case constant.Float:
				n.t = c.untypedFloat
			default:
				c.err(n.Op, "TODO %v %v %q %v %v -> %v %v", lv, lt, n.Op.Src(), rv, rt, n.v, n.v.Kind())
			}
		case isAnyUntypedType(lt) && !isAnyUntypedType(rt):
			c.err(n.Op, "TODO %v %v %q %v %v", lv, lt, n.Op.Src(), rv, rt)
		case !isAnyUntypedType(lt) && isAnyUntypedType(rt):
			c.err(n.Op, "TODO %v %v %q %v %v", lv, lt, n.Op.Src(), rv, rt)
		default: // case !isAnyUntypedType(lt) && !isAnyUntypedType(rt):
			c.err(n.Op, "TODO %v %v %q %v %v", lv, lt, n.Op.Src(), rv, rt)
		}
	default:
		c.err(n.Op, "TODO %v %v %q %v %v", lv, lt, n.Op.Src(), rv, rt)
	}
	return n
}

func (n *BinaryExpressionNode) clone() Expression {
	panic(todo("%v: %T %s", n.Position(), n, n.Source(false)))
}

func (n *UnaryExprNode) checkExpr(c *ctx) Expression {
	if n == nil {
		return nil
	}

	if n.typeCache.Type() != Invalid {
		return n
	}

	n.UnaryExpr = n.UnaryExpr.checkExpr(c)
	v := n.UnaryExpr.Value()
	t := n.UnaryExpr.Type()
	switch n.Op.Ch() {
	default:
		trc("", v, t)
		panic(todo("%v: %T %s", n.Op.Position(), n, n.Source(false)))
	}
}

func (n *UnaryExprNode) clone() Expression {
	panic(todo("%v: %T %s", n.Position(), n, n.Source(false)))
}

func (c *ctx) convertValue(n Node, v constant.Value, to Type) (r constant.Value) {
	if !known(v) {
		return unknown
	}

	switch to.Kind() {
	case
		Complex128,
		Complex64,
		Function,
		Interface,
		Map,
		Pointer,
		Slice,
		String,
		Struct,
		Tuple,
		UnsafePointer,
		UntypedBool,
		UntypedComplex,
		UntypedFloat,
		UntypedInt,
		UntypedNil,
		UntypedRune,
		UntypedString:

		c.err(n, "TODO %v -> %v", v, to)
	case Int:
		w := constant.ToInt(v)
		if !known(w) {
			c.err(n, "cannot convert %s to %s", v, to)
			return unknown
		}

		i64, ok := constant.Int64Val(w)
		if !ok {
			c.err(n, "value %s overflows %s", v, to)
			return unknown
		}

		switch c.cfg.goarch {
		case "386", "arm":
			if i64 < math.MinInt32 || i64 > math.MaxInt32 {
				c.err(n, "value %s overflows %s", v, to)
				return unknown
			}
		}
		return w
	case Int8:
		w := constant.ToInt(v)
		if !known(w) {
			c.err(n, "cannot convert %s to %s", v, to)
			return unknown
		}

		i64, ok := constant.Int64Val(w)
		if !ok {
			c.err(n, "value %s overflows %s", v, to)
			return unknown
		}

		if i64 < math.MinInt8 || i64 > math.MaxInt8 {
			c.err(n, "value %s overflows %s", v, to)
			return unknown
		}

		return w
	case Int16:
		w := constant.ToInt(v)
		if !known(w) {
			c.err(n, "cannot convert %s to %s", v, to)
			return unknown
		}

		i64, ok := constant.Int64Val(w)
		if !ok {
			c.err(n, "value %s overflows %s", v, to)
			return unknown
		}

		if i64 < math.MinInt16 || i64 > math.MaxInt16 {
			c.err(n, "value %s overflows %s", v, to)
			return unknown
		}

		return w
	case Int32:
		w := constant.ToInt(v)
		if !known(w) {
			c.err(n, "cannot convert %s to %s", v, to)
			return unknown
		}

		i64, ok := constant.Int64Val(w)
		if !ok {
			c.err(n, "value %s overflows %s", v, to)
			return unknown
		}

		if i64 < math.MinInt32 || i64 > math.MaxInt32 {
			c.err(n, "value %s overflows %s", v, to)
			return unknown
		}

		return w
	case Int64:
		w := constant.ToInt(v)
		if !known(w) {
			c.err(n, "cannot convert %s to %s", v, to)
			return unknown
		}

		if _, ok := constant.Int64Val(w); !ok {
			c.err(n, "value %s overflows %s", v, to)
			return unknown
		}

		return w
	case Uint, Uintptr:
		w := constant.ToInt(v)
		if !known(w) {
			c.err(n, "cannot convert %s to %s", v, to)
			return unknown
		}

		u64, ok := constant.Uint64Val(w)
		if !ok {
			c.err(n, "value %s overflows %s", v, to)
			return unknown
		}

		switch c.cfg.goarch {
		case "386", "arm":
			if u64 > math.MaxUint32 {
				c.err(n, "value %s overflows %s", v, to)
				return unknown
			}
		}
		return w
	case Uint8:
		w := constant.ToInt(v)
		if !known(w) {
			c.err(n, "cannot convert %s to %s", v, to)
			return unknown
		}

		u64, ok := constant.Uint64Val(w)
		if !ok {
			c.err(n, "value %s overflows %s", v, to)
			return unknown
		}

		if u64 > math.MaxUint8 {
			c.err(n, "value %s overflows %s", v, to)
			return unknown
		}

		return w
	case Uint16:
		w := constant.ToInt(v)
		if !known(w) {
			c.err(n, "cannot convert %s to %s", v, to)
			return unknown
		}

		u64, ok := constant.Uint64Val(w)
		if !ok {
			c.err(n, "value %s overflows %s", v, to)
			return unknown
		}

		if u64 > math.MaxUint16 {
			c.err(n, "value %s overflows %s", v, to)
			return unknown
		}

		return w
	case Uint32:
		w := constant.ToInt(v)
		if !known(w) {
			c.err(n, "cannot convert %s to %s", v, to)
			return unknown
		}

		u64, ok := constant.Uint64Val(w)
		if !ok {
			c.err(n, "value %s overflows %s", v, to)
			return unknown
		}

		if u64 > math.MaxUint32 {
			c.err(n, "value %s overflows %s", v, to)
			return unknown
		}

		return w
	case Uint64:
		w := constant.ToInt(v)
		if !known(w) {
			c.err(n, "cannot convert %s to %s", v, to)
			return unknown
		}

		if _, ok := constant.Uint64Val(w); !ok {
			c.err(n, "value %s overflows %s", v, to)
			return unknown
		}

		return w
	case Float32, Float64:
		return constant.ToFloat(v)
	case Bool:
		if v.Kind() == constant.Bool {
			return v
		}
	}
	return unknown
}