www.digitalmars.com         C & C++   DMDScript  

digitalmars.D.bugs - [Issue 1594] New: version not honored for invarient declaration

reply d-bugmail puremagic.com writes:
http://d.puremagic.com/issues/show_bug.cgi?id=1594

           Summary: version not honored for invarient declaration
           Product: D
           Version: 1.022
          Platform: PC
        OS/Version: Windows
            Status: NEW
          Severity: normal
          Priority: P2
         Component: DMD
        AssignedTo: bugzilla digitalmars.com
        ReportedBy: jemandy earthlink.net


The following program does not compile in 1.022.  The error message is
"invar.d(6): statement expected to be { }, not int".

import std.stdio;

version (D_Version2)
{
        string str = "Version 2";
        invariant int myint = 2;
}
else
{
        string str = "Version 1";
        const int myint = 1;
}

void main()
{
        writefln( "str: %s\nmyint: %s", str, myint );
        return;
}

Notice that a version 1 compiler shouldn't be trying to compile the statement
where the error occurs: it's in a block designated as being for a different
version of the compiler.  Change the single occurrence of if "invariant" to
"const", and it compiles fine.  With this change, the output of the program is 

str: Version 1
myint: 1

just as you would hope.


--
Oct 18 2007
next sibling parent reply d-bugmail puremagic.com writes:
http://d.puremagic.com/issues/show_bug.cgi?id=1594






I know its not intuitive but the compiler is behaving correctly. All the code
inside a version block must be valid code for the compiler you are using.

Here is how you need to do what you want to achieve...

version(D_Version2)
{
        string str = "Version 2";
        mixin("invariant int myint = 2;");
}

else
{
        string str = "Version 1";
        const int myint = 1;
}


--
Oct 18 2007
parent reply John Mandeville <jemandy earthlink.net> writes:
d-bugmail puremagic.com Wrote:


 I know its not intuitive but the compiler is behaving correctly. All the code
 inside a version block must be valid code for the compiler you are using.
 
 Here is how you need to do what you want to achieve...
 
 version(D_Version2)
 {
         string str = "Version 2";
         mixin("invariant int myint = 2;");
 }
 
 else
 {
         string str = "Version 1";
         const int myint = 1;
 }


Hmmmm.  The following would also work:

version (D_Version2)
{
	mixin( "alias invariant int invarInt;" );
	invarInt myint = 2;
}

Unfortunately, this does not work:

version (D_Version2)
{
	mixin( "alias invariant int invarInt;" );
}
else
{
	alias const int invarInt;
}

Neither v.1 nor v. 2 likes alias of const.  (I can't figure out why neither
likes alias of const but v. 2 likes alias of invariant.  const is a storage
class, not a type modifier; but then, I  presume, the same is true for
invariant in v. 2.)

Could an invariant storage class be added to version 1 that is just equivalent
10 const?  We obviously don't want to add a new storage class semantics to
version 1--changes to v. 1 at this point should be limited essentially to bug
fixes.  However, using the word invariant with const semantics might be a small
enough change to be a worthwhile.  It would be a convenience to those trying to
develop for version 1 and version 2 sinultaneously.
Oct 19 2007
parent Bill Baxter <dnewsgroup billbaxter.com> writes:
John Mandeville wrote:

 d-bugmail puremagic.com Wrote:
 

 I know its not intuitive but the compiler is behaving correctly. All the code
 inside a version block must be valid code for the compiler you are using.

 Here is how you need to do what you want to achieve...

 version(D_Version2)
 {
         string str = "Version 2";
         mixin("invariant int myint = 2;");
 }

 else
 {
         string str = "Version 1";
         const int myint = 1;
 }


 
 Hmmmm.  The following would also work:
 
 version (D_Version2)
 {
 	mixin( "alias invariant int invarInt;" );
 	invarInt myint = 2;
 }
 
 Unfortunately, this does not work:
 
 version (D_Version2)
 {
 	mixin( "alias invariant int invarInt;" );
 }
 else
 {
 	alias const int invarInt;
 }
 
 Neither v.1 nor v. 2 likes alias of const.  (I can't figure out why neither
likes alias of const but v. 2 likes alias of invariant.  const is a storage
class, not a type modifier; but then, I  presume, the same is true for
invariant in v. 2.)
 
 Could an invariant storage class be added to version 1 that is just equivalent
10 const?  We obviously don't want to add a new storage class semantics to
version 1--changes to v. 1 at this point should be limited essentially to bug
fixes.  However, using the word invariant with const semantics might be a small
enough change to be a worthwhile.  It would be a convenience to those trying to
develop for version 1 and version 2 sinultaneously.
 


And make the type constructor flavors no ops in v1 (invariant(char)[] 
--> char[]), and make .idup synonymous with .dup.  These things would go 
a long way to making it easier to support both v1 and v2 of D I think.
Oct 19 2007
prev sibling next sibling parent d-bugmail puremagic.com writes:
http://d.puremagic.com/issues/show_bug.cgi?id=1594


thomas-dloop kuehne.cn changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
             Status|NEW                         |RESOLVED
         Resolution|                            |INVALID




--
Oct 19 2007
prev sibling parent d-bugmail puremagic.com writes:
http://d.puremagic.com/issues/show_bug.cgi?id=1594


Andrei Alexandrescu <andrei erdani.com> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
             Status|CLOSED                      |RESOLVED
                 CC|                            |andrei erdani.com


-- 
Configure issuemail: http://d.puremagic.com/issues/userprefs.cgi?tab=email
------- You are receiving this mail because: -------
Jan 26 2013