Why don't I just reopen #8005 instead, which has much more context? Then we don't split the conversation.

Oh, nevermind. #8005 was closed intentionally. I thought the vet fix had closed it via a "Fixes #nnn" line.

What's different now? Why should this stay open if #8005 was already closed?

I would love #8005 to be reopened as far as I can tell there isn't a documented "NoCopy" (or comment tag) that exist and that the go compiler detects only the above workaround and the vet trick ?

As of 1.10 we run go vet for each use of go test, so it's not obvious to me that anything else is needed.

Good to know, thanks ! so we just need noCopy -> NoCopy
(and hopefully people would have tests to go test ;-) )

Moving this check into the compiler would address a fairly important real-world use-case I have, for ensuring that Go wrappers of C++ classes are not copied in Go.

Building a project that mixes Go and C++ code from source in the same binary requires the use of a build tool other than just the go tool, which complicates any safety assumption that relies on that tool. (Specifically, go vet requires access to internal type information for the other packages, which isn't always available when using other build tools.)

(CC @alandonovan)

Naive question: could cgo do that work?

cgo can do some of the work, but there's a big gap between that and “build C++ dependencies from source”.

The mixing-Go-with-C++ use case is just a concrete example. The more general problem is the assumption that vet works for verifying global properties of a program. It's great for strictly local properties, but anything more than that relies on assumptions about the build system that don't always hold.

There is no specific proposal here. This refers to #8005, which has a lot of different ideas but, as @rsc said, they are OK-but-not-obviously-right. We can consider a specific suggestion, but in the absence of that I am going to close this issue.

@ianlancetaylor The specific proposal is a new "NoCopy" keyword or type (name doesn't matter) that would enforce at compile time that a Struct isn't copied - how it is implemented is a detail, what other specific details do you require?

Well, honestly, we need many more details. Is it a keyword or a type? If it is a type, where is it defined? If it is a keyword, what about the programs that currently use that keyword as an identifier? Where is the keyword/type used? What precisely does it mean? "Isn't copied" is vague; what exact operations are not permitted?

It's probably easiest to define as a type, maybe similar to
https://golang.org/pkg/go/types/#Const
(and same package)

though a proper keyword could be nice (probably that would be nocopy)

what precisely does it mean: like c++ deletion of copy and assignment operator; you can't copy an instance only reference it

Please show an example of how this would be used.

I'm sorry to be pedantic, but you are suggesting changing the language. That has to be pedantic. It has to be precise. Go does not have copy or assignment operators, so referring to them doesn't help.

For example, given a value v which is somehow marked as nocopy, can I write

reflect.ValueOf(&v).Indirect().Interface()

? If not, what prevents it?

As a type:

type MyStruct struct {
	types.NoCopy
	field1 Foo
	// ...
}

ok := MyStruct{}
notok := ok # compile error
oktoo := &ok # that one is ok
// ... for function return etc

As a keywords it's more tricky on where/how that would be shoved in such as it make sense with existing language syntax, maybe

type MyStruct struct,nocopy { ...

Someone with knowledge of the internals would have to comment/suggest something for how reflect would work - what happens if you do the above with a Lock today ?

Again the idea is to get a strong compile time support, not a linter kind of support, though a standard type with linter is probably a low hanging fruit giving 99% of the benefits (which again are for people to not have to reivent the existing noCopy types in dozens of packages)

no *NoCopy would fail by definition

Would this be allowed?

func (m MyStuct) F() {
//
}

no would have to be func (m *MyStuct) F() { and func NewMyStruct() *MyStruct
which is part of the benefit, not accidental, even if optimized out, copies