Bug: var mock may cause sync.Mutex to be copied about xgo HOT 6 CLOSED

Solution:

var lock sync.Mutex

func demo(){
    __xgo_lock1 := &lock
    __xgo_lock1.Lock()
    __xgo_lock2 := &lock
     defer __xgo_lock2.Unlock()
     ...
}

However if lock itself is a pointer, then we are wrong again.

var lock *sync.Mutex

func demo(){
    __xgo_lock1 := &lock
    __xgo_lock1.Lock()
    __xgo_lock2 := &lock
     defer __xgo_lock2.Unlock()
     ...
}

Another simple solution is to turn off rewritting selector expr. i.e. only direct references are intercepted.

var lock sync.Mutex

func demo(){
     lock1:=&lock // intercepted
     lock1.Lock()

     lock.Unock() // not intercepted
}

from xgo.

Another simple solution is to turn off rewritting selector expr. i.e. only direct references are intercepted.

var lock sync.Mutex

func demo(){
     lock1:=&lock // intercepted
     lock1.Lock()

     lock.Unock() // not intercepted
}

After this, some valid case may not be intercepted:

type Config struct {
     On bool
}

var cfg = &Config{}

func demo(){
    if cfg.On { // cfg is not captured
        // ...
    }
}

from xgo.

var lock sync.Mutex
...
Will be transformed to:
Is obviously wrong.

Other types include: sync.Map.

Actually this does not happen, because func names are always skipped:

func (ctx *BlockContext) traverseCallExpr(node *syntax.CallExpr, globaleNames map[string]*DeclInfo, imports map[string]string) *syntax.CallExpr {
	if node == nil {
		return nil
	}
	if ctx.ArgCallExprParent == nil {
		ctx.ArgCallExprParent = make(map[syntax.Node]*syntax.CallExpr, len(node.ArgList))
		for _, arg := range node.ArgList {
			ctx.ArgCallExprParent[arg] = node
		}
	}

	// NOTE: we skip capturing a name as a function
	// node.Fun = ctx.traverseExpr(node.Fun, globaleNames, imports)
	for i, arg := range node.ArgList {
		node.ArgList[i] = ctx.traverseExpr(arg, globaleNames, imports)
	}
	return node
}

from xgo.

However, this causes panic:

func incrLocked_Fn() {
	f := lock.Lock
	f()
	count = count + 1
	lock.Unlock()
}

fatal error: sync: unlock of unlocked mutex

from xgo.

After this, some valid case may not be intercepted:

type Config struct {
     On bool
}

var cfg = &Config{}

func demo(){
    if cfg.On { // cfg is not captured
        // ...
    }
}

For cases where copy is allowed, we can add a comment to the definition to tell xgo allow it:

// xgo:trap
var cfg = &Config{}

from xgo.

After this, some valid case may not be intercepted:

type Config struct {
     On bool
}

var cfg = &Config{}

func demo(){
    if cfg.On { // cfg is not captured
        // ...
    }
}

For cases where copy is allowed, we can add a comment to the definition to tell xgo allow it:

// xgo:trap
var cfg = &Config{}

But since current syntax does not include comments, we cannot tell what the user want to do.

So we instead of comment ,use this:

const __xgo_trap_cfg = 1
var cfg = &Config{}

from xgo.