func.go

/*
 Copyright 2021 The XGo Authors (xgo.dev)
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
     http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
*/

package gogen

import (
	"fmt"
	"go/ast"
	"go/token"
	"go/types"
	"log"

	"github.com/goplus/gogen/internal"
	"github.com/goplus/gogen/target"
)

// ----------------------------------------------------------------------------

// NewParam returns a new variable representing a function parameter with optional flag.
func (p *Package) NewParam(pos token.Pos, name string, typ types.Type, optional bool) *types.Var {
	param := types.NewParam(pos, p.Types, name, typ)
	if optional {
		p.setParamOptional(param)
	}
	return param
}

// ----------------------------------------------------------------------------

// Func type
type Func struct {
	*types.Func
	decl   *funcDecl
	cate   AutoLambdaCategory
	old    funcBodyCtx
	arity1 int // 0 for normal, (arity+1) for inlineClosure
}

// Obj returns this function object.
func (p *Func) Obj() types.Object {
	return p.Func
}

// Comments returns associated documentation.
func (p *Func) Comments() *ast.CommentGroup {
	return p.decl.Doc
}

// SetComments sets associated documentation.
func (p *Func) SetComments(pkg *Package, doc *ast.CommentGroup) *Func {
	p.decl.Doc = doc
	pkg.setDoc(p.Func, doc)
	return p
}

// Ancestor returns ancestor of a closure function.
// It returns itself if the specified func is a normal function.
func (p *Func) Ancestor() *Func {
	for p.Name() == "" && p.old.fn != nil {
		p = p.old.fn
	}
	return p
}

// BodyStart func
func (p *Func) BodyStart(pkg *Package, src ...ast.Node) *CodeBuilder {
	if debugInstr {
		var recv string
		tag := "NewFunc "
		name := p.Name()
		sig := p.Type().(*types.Signature)
		if v := sig.Recv(); IsMethodRecv(v) {
			recv = fmt.Sprintf(" (%v)", v.Type())
		}
		if name == "" {
			tag = "NewClosure"
		}
		log.Printf("%v%v%v %v\n", tag, name, recv, sig)
	}
	return pkg.cb.startFuncBody(p, src, &p.old)
}

const (
	cantUseFlowsInAutoLambda = "can't use return/continue/break/goto in auto lambda"
)

// End is for internal use.
func (p *Func) End(cb *CodeBuilder, src ast.Node) {
	if p.isInline() {
		p.inlineClosureEnd(cb)
		return
	}

	pkg := cb.pkg
	checker := termChecker{cb.current.panicCalls}
	fnBody, flows := cb.endFuncBody(p.old)
	cate := p.cate
	if cate != AutoLambdaNormal {
		if flows != 0 {
			cb.handleCodeError(getSrcPos(src), getSrcEnd(src), cantUseFlowsInAutoLambda)
		} else {
			fnBody = return0IfNeeded(fnBody)
		}
	}
	body := &target.BlockStmt{List: fnBody}
	t := p.Type().(*types.Signature)

	// Check for missing return at the closing brace position.
	// For FuncDecl/FuncLit/BlockStmt, End() returns Rbrace+1, so End()-1 is the Rbrace position.
	if cate == AutoLambdaNormal && t.Results().Len() > 0 && !checker.isTerminating(body, "") {
		pos, end := token.NoPos, token.NoPos
		if src != nil {
			end = src.End()
			pos = end - 1
		}
		cb.handleCodeError(pos, end, "missing return")
	}

	if fn := p.decl; fn == nil { // is closure
		expr := newFuncLit(pkg, t, body)
		cb.stk.Push(&internal.Elem{Val: expr, Type: t, Src: src})
	} else {
		fn.Name, fn.Type, fn.Body = &ast.Ident{Name: p.Name()}, toFuncType(pkg, t), body
		if recv := t.Recv(); IsMethodRecv(recv) {
			fn.Recv = toRecv(pkg, recv)
		}
	}
}

// NewFuncDecl creates a new function without function body (declaration only).
func (p *Package) NewFuncDecl(pos token.Pos, name string, sig *types.Signature) *Func {
	f, err := p.NewFuncWith(pos, name, sig, nil)
	if err != nil {
		panic(err)
	}
	fn := f.decl
	fn.Name, fn.Type = &ast.Ident{Name: name}, toFuncType(p, sig)
	return f
}

// validateParamOrder validates that optional parameters come after positional parameters
// and before any variadic parameter.
// Valid order: positional → optional → variadic
func (p *Package) validateParamOrder(cb *CodeBuilder, pos token.Pos, params *types.Tuple, variadic bool) error {
	n := params.Len()
	foundOptional := false

	for i := 0; i < n; i++ {
		param := params.At(i)
		isOptional := p.isParamOptional(param)

		// If variadic is true, the last parameter is the variadic parameter
		isVariadicParam := variadic && i == n-1

		if isOptional {
			if isVariadicParam {
				// Optional parameter cannot also be variadic
				return cb.newCodeErrorf(param.Pos(), param.Pos(), "variadic parameter cannot be optional")
			}
			foundOptional = true
		} else if foundOptional && !isVariadicParam {
			// Found a positional parameter after an optional one (and it's not the variadic param)
			return cb.newCodeErrorf(param.Pos(), param.Pos(), "positional parameter %s must come before optional parameters", param.Name())
		}
	}

	return nil
}

// NewFunc creates a new function (should have a function body).
func (p *Package) NewFunc(recv *types.Var, name string, params, results *types.Tuple, variadic bool) *Func {
	sig := types.NewSignatureType(recv, nil, nil, params, results, variadic)
	f, err := p.NewFuncWith(token.NoPos, name, sig, nil)
	if err != nil {
		panic(err)
	}
	return f
}

func getRecv(recvTypePos func() token.Pos) token.Pos {
	if recvTypePos != nil {
		return recvTypePos()
	}
	return token.NoPos
}

func IsMethodRecv(recv *types.Var) bool {
	return recv != nil
}

// NewFuncWith creates a new function (should have a function body).
func (p *Package) NewFuncWith(
	pos token.Pos, name string, sig *types.Signature, recvTypePos func() token.Pos) (*Func, error) {
	if name == "" {
		panic("no func name")
	}
	cb := p.cb
	if err := p.validateParamOrder(&cb, pos, sig.Params(), sig.Variadic()); err != nil {
		return nil, err
	}
	fn := &Func{Func: types.NewFunc(pos, p.Types, name, sig)}
	if recv := sig.Recv(); IsMethodRecv(recv) { // add method to this type
		var t *types.Named
		var ok bool
		var typ = recv.Type()
		switch tt := typ.(type) {
		case *types.Named:
			t, ok = tt, true
		case *types.Pointer:
			typ = tt.Elem()
			t, ok = typ.(*types.Named)
		}
		if !ok {
			posErr := getRecv(recvTypePos)
			return nil, cb.newCodeErrorf(posErr, posErr, "invalid receiver type %v (%v is not a defined type)", typ, typ)
		}
		switch getUnderlying(p, t.Obj().Type()).(type) {
		case *types.Interface:
			posErr := getRecv(recvTypePos)
			return nil, cb.newCodeErrorf(posErr, posErr, "invalid receiver type %v (%v is an interface type)", typ, typ)
		case *types.Pointer:
			posErr := getRecv(recvTypePos)
			return nil, cb.newCodeErrorf(posErr, posErr, "invalid receiver type %v (%v is a pointer type)", typ, typ)
		}
		if name != "_" { // skip underscore
			if _, obj := lookupStaticMember(t, name); obj != nil {
				return nil, cb.newCodeErrorf(pos, pos, "method %s conflicts with existing %s", name, staticMemberKind(obj))
			}
			t.AddMethod(fn.Func)
		}
	} else if name == "init" { // init is not a normal func
		if sig.Params() != nil || sig.Results() != nil {
			return nil, cb.newCodeErrorf(
				pos, pos, "func init must have no arguments and no return values")
		}
	} else if name != "_" { // skip underscore
		old := p.Types.Scope().Insert(fn.Obj())
		if old != nil {
			if !(p.allowRedecl && types.Identical(old.Type(), sig)) { // for c2go
				oldPos := cb.fset.Position(old.Pos())
				return nil, cb.newCodeErrorf(
					pos, pos, "%s redeclared in this block\n\t%v: other declaration of %s", name, oldPos, name)
			}
		}
		p.useName(name)
	}

	if isXGoFunc(name) {
		p.isXGoPkg = true
	}
	if token.IsExported(name) {
		p.expObjTypes = append(p.expObjTypes, sig)
	}

	fn.decl = &funcDecl{}
	p.file.appendFuncDecl(fn.decl, sig)
	return fn, nil
}

func (p *Package) newClosure(sig *types.Signature, cate AutoLambdaCategory) *Func {
	fn := types.NewFunc(token.NoPos, p.Types, "", sig)
	return &Func{Func: fn, cate: cate}
}

func (p *Package) newInlineClosure(sig *types.Signature, arity int) *Func {
	fn := types.NewFunc(token.NoPos, p.Types, "", sig)
	return &Func{Func: fn, arity1: arity + 1}
}

func (p *Func) isInline() bool {
	return p.arity1 != 0
}

func (p *Func) getInlineCallArity() int {
	return p.arity1 - 1
}

// ----------------------------------------------------------------------------

type Element = internal.Elem
type InstrFlags token.Pos

const (
	InstrFlagEllipsis InstrFlags = 1 << iota

	instrFlagApproxType // restricts to all types whose underlying type is T
	instrFlagXGoxFunc   // call XGox_xxx function
	instrFlagXGotFunc   // call XGot_xxx function
	instrFlagBinaryOp   // from cb.BinaryOp
	instrFlagUntyped    // return type should be mapped to the corresponding untyped kind
)

type Instruction interface {
	Call(pkg *Package, args []*Element, lhs int, flags InstrFlags, src ast.Node) (ret *Element, err error)
}

// ----------------------------------------------------------------------------