[svn] r6441: nemerle/trunk: macros/concurrency.n ncc/generation/Typer4.n ncc/typing/TypedTree.n

[nazgul]

Log:
More changes needed to make initonly work

Author: nazgul
Date: Sun Jul  9 14:08:35 2006
New Revision: 6441

Modified:
   nemerle/trunk/macros/concurrency.n
   nemerle/trunk/ncc/generation/Typer4.n
   nemerle/trunk/ncc/typing/TypedTree.n

Modified: nemerle/trunk/macros/concurrency.n
==============================================================================
--- nemerle/trunk/macros/concurrency.n	(original)
+++ nemerle/trunk/macros/concurrency.n	Sun Jul  9 14:08:35 2006
@@ -104,11 +104,9 @@
         }
         unless (is_in_current (tb.LookupMember ("__Chord_Mask"))) {
           tb.Define (<[ decl:
-            __Chord_Mask : BitMask;
+            mutable __Chord_Mask : BitMask = BitMask (); // it must be mutable, otherwise on every use .NET creates just its copy and does not
+                                                         // modify it in place
           ]>);
-          AddInit (tb, false, <[
-            this.__Chord_Mask = BitMask ();
-          ]>)
         }
 
         unless (is_in_current (tb.LookupMember ("__Chord_Lock"))) {

Modified: nemerle/trunk/ncc/generation/Typer4.n
==============================================================================
--- nemerle/trunk/ncc/generation/Typer4.n	(original)
+++ nemerle/trunk/ncc/generation/Typer4.n	Sun Jul  9 14:08:35 2006
@@ -475,9 +475,8 @@
             def obj = Walk (obj);
               
             // use address here for better performance
-            when (! obj.NeedAddress && fld.DeclaringType.IsValueType && fld.IsMutable) {
-              obj.setNeedAddress (is_instance_ctor);
-            }
+            when (! obj.NeedAddress && fld.DeclaringType.IsValueType && fld.IsMutable)
+              _= obj.setNeedAddress (is_instance_ctor);
               
             TExpr.FieldMember (obj, fld)
 
@@ -510,7 +509,9 @@
               Message.Error ("this expression is not a proper lvalue: "
                              "cannot load value type address");
             else
-              e1.setNeedAddress (is_instance_ctor);
+              unless (e1.setNeedAddress (is_instance_ctor))
+                Message.Error ("this expression is not a proper lvalue: "
+                               "cannot load value type address");
           
             if (NeedBoxing (real_type, e2))
               TExpr.Assign (InternalType.Void, e1, Box (real_type, e2))
@@ -521,7 +522,7 @@
             def e1 = Walk (e1);
             def e2 = Walk (e2);
             if (decl.IsCache && decl.Type.Fix ().IsValueType) {
-              e1.setNeedAddress (is_instance_ctor);
+              _ = e1.setNeedAddress (is_instance_ctor);
               decl.IsManagedPtr = true;
               TExpr.DefValIn (decl, e1, e2)
             } else if (NeedBoxing (decl.Type.Fix (), e1))
@@ -553,14 +554,14 @@
                 | MethodRef (obj, meth, type_parms, nonvirt) =>
                   if (obj.MType is MType.TyVarRef) {
                     obj.NeedsConstrained = true;
-                    obj.setNeedAddress (is_instance_ctor);
+                    _ = obj.setNeedAddress (is_instance_ctor);
                   }
                   else
                   // we would kinda like address here
                   when (obj.Type.Fix ().IsValueType) {
                     def methty = meth.DeclaringType;
                     if (methty.IsValueType)
-                      obj.setNeedAddress (is_instance_ctor);
+                      _ = obj.setNeedAddress (is_instance_ctor);
                     else {
                       // but maybe we should employ boxing
                       def obj = Box (methty.GetMemType (), obj);
@@ -605,9 +606,7 @@
                           when (NeedBoxing (t, parm.expr))
                             parm.expr = Box (t, parm.expr);
                       } else {
-                        if (parm.expr.IsAddressable)
-                          parm.expr.setNeedAddress (is_instance_ctor);
-                        else
+                        unless (parm.expr.IsAddressable && parm.expr.setNeedAddress (is_instance_ctor))
                           Message.Error ($ "non-addressable expression passed "
                                            "as a ref/out parameter");
                       }

Modified: nemerle/trunk/ncc/typing/TypedTree.n
==============================================================================
--- nemerle/trunk/ncc/typing/TypedTree.n	(original)
+++ nemerle/trunk/ncc/typing/TypedTree.n	Sun Jul  9 14:08:35 2006
@@ -609,7 +609,7 @@
       get { flags %&& TExprFlags.NeedAddress }
     }
     
-    internal setNeedAddress (from_ctor : bool) : void {
+    internal setNeedAddress (from_ctor : bool) : bool {
       Util.cassert (! NeedAddress);
 
       match (this) {
@@ -617,18 +617,23 @@
         | LocalRef
         | ArrayIndexer
         | This =>
-          flags |= TExprFlags.NeedAddress
+          flags |= TExprFlags.NeedAddress;
+          true
         
         | FieldMember (This as obj, fld) with is_mutable = from_ctor || fld.IsMutable
-        | FieldMember (obj, fld) with is_mutable = fld.IsMutable =>
-          when (is_mutable) {
+        | FieldMember (obj, fld) with is_mutable = fld.IsMutable || fld.Attributes %&& NemerleAttributes.CompilerMutable =>
+          if (is_mutable) {
           //Message.Debug ($"am being assigned $this");              
             flags |= TExprFlags.NeedAddress;
-            when (fld.DeclaringType.IsValueType && !obj.NeedAddress)
+            if (fld.DeclaringType.IsValueType && !obj.NeedAddress)
               obj.setNeedAddress (from_ctor);
+            else
+              true
           }
+          else
+            false
             
-        | _ => {}
+        | _ => false
       }
     }
     #endregion