www.digitalmars.com         C & C++   DMDScript  

digitalmars.D - "private:" remains in effect after end of containing attribute{}

reply Frits van Bommel <fvbommel REMwOVExCAPSs.nl> writes:
Something I ran into today:
=====
$ cat test.d
import std.stdio;
import a;

void main()
{
     auto a = new A;
     writefln(a.b);
}
$ cat a.d
struct A {
     final {
         private:
         int a;
     }
     static bool b;
}
$ dmd test.d a.d
test.d(7): struct a.A member b is not accessible
=====
(After commenting out the "private:" line it compiles fine)

Is that error supposed to happen?
Shouldn't the one of the block endings stop the "private:" from 
remaining in effect afterwards?

The spec seems to be very clear on this. 
http://www.digitalmars.com/d/attribute.html says the "attribute:" syntax 
"affects all declarations until the next }".


(http://d.puremagic.com/issues/show_bug.cgi?id=1090) to change that 
sentence since as it stands now things like "version(Windows) { 
extern(Windows): }" should technically have no effect on anything, 
though the compiler doesn't implement it that way)

Since IMHO either that sentence or the compiler should be changed 
anyway, perhaps there should be some discussion about /which/ closing 
}'s should end the effects of an "attribute:" line.
Any thoughts?
Apr 06 2007
parent reply Daniel Keep <daniel.keep.lists gmail.com> writes:
Frits van Bommel wrote:

 Something I ran into today:
 =====
 $ cat test.d
 import std.stdio;
 import a;
 
 void main()
 {
     auto a = new A;
     writefln(a.b);
 }
 $ cat a.d
 struct A {
     final {
         private:
         int a;
     }
     static bool b;
 }
 $ dmd test.d a.d
 test.d(7): struct a.A member b is not accessible
 =====
 (After commenting out the "private:" line it compiles fine)
 
 Is that error supposed to happen?
 Shouldn't the one of the block endings stop the "private:" from
 remaining in effect afterwards?
 
 The spec seems to be very clear on this.
 http://www.digitalmars.com/d/attribute.html says the "attribute:" syntax
 "affects all declarations until the next }".
 

 (http://d.puremagic.com/issues/show_bug.cgi?id=1090) to change that
 sentence since as it stands now things like "version(Windows) {
 extern(Windows): }" should technically have no effect on anything,
 though the compiler doesn't implement it that way)
 
 Since IMHO either that sentence or the compiler should be changed
 anyway, perhaps there should be some discussion about /which/ closing
 }'s should end the effects of an "attribute:" line.
 Any thoughts?


I believe this is because it *should* say: "affects all declarations
until the end of the scope", and "final { ... }" doesn't introduce a scope.

	-- Daniel

-- 
int getRandomNumber()
{
    return 4; // chosen by fair dice roll.
              // guaranteed to be random.
}

http://xkcd.com/

v2sw5+8Yhw5ln4+5pr6OFPma8u6+7Lw4Tm6+7l6+7D
i28a2Xs3MSr2e4/6+7t4TNSMb6HTOp5en5g6RAHCP  http://hackerkey.com/
Apr 06 2007
parent reply Bill Baxter <dnewsgroup billbaxter.com> writes:
Daniel Keep wrote:

 
 I believe this is because it *should* say: "affects all declarations
 until the end of the scope", and "final { ... }" doesn't introduce a scope.


These non-scope curly braces have always made me uneasy.  Makes it 
difficult for my C++-adjusted eyes to tell at a glance what's still 
active and what's not.  I guess C++ has the "namespace {}" non-scope 
block, but that's only used at the top level scope so use cases can't 
get too complicated.

As for an alternative, I guess you could play around with alternate 
block delimiters for non-scope blocks

static if (is(foo==bar)) <<
     writefln("hello world")




static if (is(foo==bar)) :{
     writefln("hello world")
}:

static if (is(foo==bar)) |{
     writefln("hello world")
}|

static if (is(foo==bar)) ::
     writefln("hello world")
::

I kind of like ':{ }:'  The colons are like a dotted line, a 1-D sieve 
if you will, indicating that things can 'pass through' this block.  Also 
meshes well with the non-scoping tags like "private:"

You could phase it in with three-step plan:
1) add :{ }: (or whatever) as an alternate syntax which can be used for 
"non-scope block" in the current non-scope contexts (static if, version, 
public etc)

2) deprecate/warn about uses of plain {} with non-scope blocks.

3) make plain {} with non-scope blocks an error.

4) Finally, reintroduce the ability to use {} with things like static 
if, but this time have them really create a scope (where a scope makes 
sense). This way we can ultimately get back to the shiny happy rule of 
'{ }' always makes a scope whenever it can.

On the other hand, no one else seems to be bothered by this but me.   I 
thought I'd get this off my chest anyway.  :-)

--bb



 Apr 06 2007



  parent  janderson <askme me.com>  writes:


Bill Baxter wrote:

 Daniel Keep wrote:

 I believe this is because it *should* say: "affects all declarations
 until the end of the scope", and "final { ... }" doesn't introduce a 
 scope.


 
 These non-scope curly braces have always made me uneasy.  Makes it 
 difficult for my C++-adjusted eyes to tell at a glance what's still 
 active and what's not.  I guess C++ has the "namespace {}" non-scope 
 block, but that's only used at the top level scope so use cases can't 
 get too complicated.
 
 As for an alternative, I guess you could play around with alternate 
 block delimiters for non-scope blocks
 
 static if (is(foo==bar)) <<
     writefln("hello world")
  >>
 
 static if (is(foo==bar)) :{
     writefln("hello world")
 }:
 
 static if (is(foo==bar)) |{
     writefln("hello world")
 }|
 
 static if (is(foo==bar)) ::
     writefln("hello world")
 ::
 
 I kind of like ':{ }:'  The colons are like a dotted line, a 1-D sieve 
 if you will, indicating that things can 'pass through' this block.  Also 
 meshes well with the non-scoping tags like "private:"
 
 You could phase it in with three-step plan:
 1) add :{ }: (or whatever) as an alternate syntax which can be used for 
 "non-scope block" in the current non-scope contexts (static if, version, 
 public etc)
 
 2) deprecate/warn about uses of plain {} with non-scope blocks.
 
 3) make plain {} with non-scope blocks an error.
 
 4) Finally, reintroduce the ability to use {} with things like static 
 if, but this time have them really create a scope (where a scope makes 
 sense). This way we can ultimately get back to the shiny happy rule of 
 '{ }' always makes a scope whenever it can.
 
 On the other hand, no one else seems to be bothered by this but me.   I 
 thought I'd get this off my chest anyway.  :-)
 
 --bb


This is a good idea.  I've been bothered by the non-bracketable static 
ifs as well.  I think the smilely faces are the easiest to read.

-Joel



 Apr 07 2007