Prohibit expressionless var declarations for structs with unexported fields

[gopherbot]

by eadfrith:

Go prohibits composite literal expressions for structs with unexported
fields. This is good, as it allows the package author to control the way in
which instances of such structs are initialized.

However, variable declarations for the same structs are allowed to occur
without an explicit initializer. The struct is then initialized to its zero
value - which may be invalid. Currently there is no way for the package
author to prevent a client from creating an invalid instance of a struct.

Consider the following silly example: 

package foo

// Incr holds a value and its cached increment
type Incr struct
{
  val, ival int; 
}

func NewIncr(v int) Incr
{
  return Incr{v, v+1};
}

func (i *Incr) Valid() (bool)
{
  return i.val == i.ival-1;
}

Client:

package main

import "foo";

func main()
{   
  // intended usage: use factory to create a valid instance
  valid := foo.NewIncr(1);

  // compiler blocks composite literals for struct with unexported fields
  // illegal := foo.Incr{};  // implicit assignment of foo.Incr field 'val'
    
  // but declaration without explicit initialization is allowed
  var invalid foo.Incr; // invalid instance
}

[gopherbot]

Comment 1 by FrederickMayle:

What if you want something like this:
struct incrContainer {
    var incr foo.Incr;
}
func main() {
    var x incrContainer;
    x.incr = foo.NewIncr(1);
}
You could use pointers instead but that isn't the best idea if you are trying to 
avoid memory fragmentation.

[griesemer]

Comment 2:

Owner changed to g...@golang.org.

Status changed to Thinking.

[rsc]

Comment 3:

var x Incr is almost, but not quite, useless.
The only thing you can do with it is take its address.
There's a real bug here too:
illegal := foo.Incr{}'s error probably happens on 
illegal := &foo.Incr{} too, but that should work.

Labels changed: added language-change.

[rsc]

Comment 4:

Labels changed: added languagechange, removed language-change.

[rsc]

Comment 5:

In the course of cleaning up this code to fix a few bugs
pointed out on the mailing list, I came across the following
example:
    var mu sync.Mutex;
It seems entirely reasonable to me to write a program like:
    var mu sync.Mutex;
    var data int;
    go func() {
        mu.Lock();
        ... use data ...
        mu.Unlock();
    }();
    mu.Lock();
    ... other use of data ...
    mu.Unlock();
That might reasonably come up as part of a larger program,
and it seems unnecessary to force programmers to write
    mu := new(Mutex);
instead of using the simpler declaration.

Status changed to WontFix.

[stevenblenkinsop]

Comment 6:

Its also a non issue. If you want complete control of your type, you don't have to
export it. You can still have an initializer return your type, and the function
caller can still access all its exported methods and fields, but can never refer to
it by name. So no blank struct literals, no new() declarations, no var X t, no
asserting or converting to your type, meaning you still have full control over over
what's in your object. 
(I'm assuming that the fact that you can do this is a feature not a bug. It certainly
surprised me when I did it by accident. I still can't figure out how someone is
supposed to be able to call the methods of a type without being able to refer to the
type. I'd assumed you'd need to embed to get this functionality. But its darned handy)

[rsc]

Comment 7:

Having an initializer return a pointer to a non-exported type
is possible but not terribly useful.  Among other things, the
client can't even store that pointer in a data structure
because it cannot declare the data structure.  And the documentation
won't show up because it is an unexported type.
It's allowed because it's a consequence of the rules,
and we like the rules.
A more common approach, in this situation, is to define the
interface that the returned type implements (or pull it from
somewhere else), and completely hide the type name.
Package hash/crc32 and hash/adler32 do this: they have
constructors that return simply hash.Hash, which completely
hides even what the underlying unexported type is called.