Use 'in' instead of 'ref' where possible

SergeiPavlov · SergeiPavlov · commit f505c3fdf3de · 2022-03-15T21:40:13.000-07:00
diff --git a/Orm/Xtensive.Orm/Tuples/AccessorDelegates.cs b/Orm/Xtensive.Orm/Tuples/AccessorDelegates.cs
@@ -16,7 +16,7 @@ namespace Xtensive.Tuples
   /// <param name="descriptor">Field descriptor.</param>
   /// <param name="fieldState">State of a field.</param>
   /// <returns></returns>
-  internal delegate TValue GetValueDelegate<TValue>(PackedTuple tuple, ref PackedFieldDescriptor descriptor, out TupleFieldState fieldState);
+  internal delegate TValue GetValueDelegate<TValue>(PackedTuple tuple, in PackedFieldDescriptor descriptor, out TupleFieldState fieldState);
 
   /// <summary>
   /// Incapsulates <see cref="Tuple.SetValue{T}"/> method.
diff --git a/Orm/Xtensive.Orm/Tuples/Packed/PackedFieldAccessor.cs b/Orm/Xtensive.Orm/Tuples/Packed/PackedFieldAccessor.cs
@@ -47,32 +47,32 @@ public void SetValue<T>(PackedTuple tuple, ref PackedFieldDescriptor descriptor,
         SetUntypedValue(tuple, ref descriptor, value);
     }
 
-    public T GetValue<T>(PackedTuple tuple, ref PackedFieldDescriptor descriptor, bool isNullable, out TupleFieldState fieldState)
+    public T GetValue<T>(PackedTuple tuple, in PackedFieldDescriptor descriptor, bool isNullable, out TupleFieldState fieldState)
     {
       var getter = (isNullable ? NullableGetter : Getter) as GetValueDelegate<T>;
       if (getter!=null)
-        return getter.Invoke(tuple, ref descriptor, out fieldState);
+        return getter.Invoke(tuple, descriptor, out fieldState);
       var targetType = typeof (T);
 
       //Dirty hack of nullable enum reading
       if (isNullable)
         targetType = Nullable.GetUnderlyingType(targetType) ?? targetType;
       if (targetType.IsEnum)
-        return (T) Enum.ToObject(targetType, GetUntypedValue(tuple, ref descriptor, out fieldState));
-      return (T) GetUntypedValue(tuple, ref descriptor, out fieldState);
+        return (T) Enum.ToObject(targetType, GetUntypedValue(tuple, descriptor, out fieldState));
+      return (T) GetUntypedValue(tuple, descriptor, out fieldState);
     }
 
-    public abstract object GetUntypedValue(PackedTuple tuple, ref PackedFieldDescriptor descriptor, out TupleFieldState fieldState);
+    public abstract object GetUntypedValue(PackedTuple tuple, in PackedFieldDescriptor descriptor, out TupleFieldState fieldState);
 
     public abstract void SetUntypedValue(PackedTuple tuple, ref PackedFieldDescriptor descriptor, object value);
 
     public abstract void CopyValue(PackedTuple source, ref PackedFieldDescriptor sourceDescriptor,
       PackedTuple target, ref PackedFieldDescriptor targetDescriptor);
 
-    public abstract bool ValueEquals(PackedTuple left, ref PackedFieldDescriptor leftDescriptor,
-      PackedTuple right, ref PackedFieldDescriptor rightDescriptor);
+    public abstract bool ValueEquals(PackedTuple left, in PackedFieldDescriptor leftDescriptor,
+      PackedTuple right, in PackedFieldDescriptor rightDescriptor);
 
-    public abstract int GetValueHashCode(PackedTuple tuple, ref PackedFieldDescriptor descriptor);
+    public abstract int GetValueHashCode(PackedTuple tuple, in PackedFieldDescriptor descriptor);
 
     protected PackedFieldAccessor(int rank, byte index)
     {
@@ -101,9 +101,9 @@ protected PackedFieldAccessor(int rank, byte index)
 
   internal sealed class ObjectFieldAccessor : PackedFieldAccessor
   {
-    public override object GetUntypedValue(PackedTuple tuple, ref PackedFieldDescriptor descriptor, out TupleFieldState fieldState)
+    public override object GetUntypedValue(PackedTuple tuple, in PackedFieldDescriptor descriptor, out TupleFieldState fieldState)
     {
-      var state = tuple.GetFieldState(ref descriptor);
+      var state = tuple.GetFieldState(descriptor);
       fieldState = state;
       return state==TupleFieldState.Available ? tuple.Objects[descriptor.ObjectIndex] : null;
     }
@@ -123,15 +123,15 @@ public override void CopyValue(PackedTuple source, ref PackedFieldDescriptor sou
       target.Objects[targetDescriptor.ObjectIndex] = source.Objects[sourceDescriptor.ObjectIndex];
     }
 
-    public override bool ValueEquals(PackedTuple left, ref PackedFieldDescriptor leftDescriptor,
-      PackedTuple right, ref PackedFieldDescriptor rightDescriptor)
+    public override bool ValueEquals(PackedTuple left, in PackedFieldDescriptor leftDescriptor,
+      PackedTuple right, in PackedFieldDescriptor rightDescriptor)
     {
       var leftValue = left.Objects[leftDescriptor.ObjectIndex];
       var rightValue = right.Objects[rightDescriptor.ObjectIndex];
       return leftValue.Equals(rightValue);
     }
 
-    public override int GetValueHashCode(PackedTuple tuple, ref PackedFieldDescriptor descriptor)
+    public override int GetValueHashCode(PackedTuple tuple, in PackedFieldDescriptor descriptor)
     {
       return tuple.Objects[descriptor.ObjectIndex].GetHashCode();
     }
@@ -167,11 +167,11 @@ internal abstract class ValueFieldAccessor<T> : ValueFieldAccessor
 
     protected virtual T Decode(long[] values, int offset) => throw new NotSupportedException();
 
-    public override object GetUntypedValue(PackedTuple tuple, ref PackedFieldDescriptor descriptor, out TupleFieldState fieldState)
+    public override object GetUntypedValue(PackedTuple tuple, in PackedFieldDescriptor descriptor, out TupleFieldState fieldState)
     {
-      var state = tuple.GetFieldState(ref descriptor);
+      var state = tuple.GetFieldState(descriptor);
       fieldState = state;
-      return state==TupleFieldState.Available ? (object) Load(tuple, ref descriptor) : null;
+      return state==TupleFieldState.Available ? (object) Load(tuple, descriptor) : null;
     }
 
     public override void SetUntypedValue(PackedTuple tuple, ref PackedFieldDescriptor descriptor, object value)
@@ -188,34 +188,34 @@ public override void SetUntypedValue(PackedTuple tuple, ref PackedFieldDescripto
     public override void CopyValue(PackedTuple source, ref PackedFieldDescriptor sourceDescriptor,
       PackedTuple target, ref PackedFieldDescriptor targetDescriptor)
     {
-      Store(target, ref targetDescriptor, Load(source, ref sourceDescriptor));
+      Store(target, ref targetDescriptor, Load(source, sourceDescriptor));
     }
 
-    public override bool ValueEquals(PackedTuple left, ref PackedFieldDescriptor leftDescriptor,
-      PackedTuple right, ref PackedFieldDescriptor rightDescriptor)
+    public override bool ValueEquals(PackedTuple left, in PackedFieldDescriptor leftDescriptor,
+      PackedTuple right, in PackedFieldDescriptor rightDescriptor)
     {
-      var leftValue = Load(left, ref leftDescriptor);
-      var rightValue = Load(right, ref rightDescriptor);
+      var leftValue = Load(left, leftDescriptor);
+      var rightValue = Load(right, rightDescriptor);
       return leftValue.Equals(rightValue);
     }
 
-    public override int GetValueHashCode(PackedTuple tuple, ref PackedFieldDescriptor descriptor)
+    public override int GetValueHashCode(PackedTuple tuple, in PackedFieldDescriptor descriptor)
     {
-      return Load(tuple, ref descriptor).GetHashCode();
+      return Load(tuple, descriptor).GetHashCode();
     }
 
-    private T GetValue(PackedTuple tuple, ref PackedFieldDescriptor descriptor, out TupleFieldState fieldState)
+    private T GetValue(PackedTuple tuple, in PackedFieldDescriptor descriptor, out TupleFieldState fieldState)
     {
-      var state = tuple.GetFieldState(ref descriptor);
+      var state = tuple.GetFieldState(descriptor);
       fieldState = state;
-      return state==TupleFieldState.Available ? Load(tuple, ref descriptor) : DefaultValue;
+      return state==TupleFieldState.Available ? Load(tuple, descriptor) : DefaultValue;
     }
 
-    private T? GetNullableValue(PackedTuple tuple, ref PackedFieldDescriptor descriptor, out TupleFieldState fieldState)
+    private T? GetNullableValue(PackedTuple tuple, in PackedFieldDescriptor descriptor, out TupleFieldState fieldState)
     {
-      var state = tuple.GetFieldState(ref descriptor);
+      var state = tuple.GetFieldState(descriptor);
       fieldState = state;
-      return state==TupleFieldState.Available ? Load(tuple, ref descriptor) : NullValue;
+      return state==TupleFieldState.Available ? Load(tuple, descriptor) : NullValue;
     }
 
     private void SetValue(PackedTuple tuple, ref PackedFieldDescriptor descriptor, T value)
@@ -249,7 +249,7 @@ private void Store(PackedTuple tuple, ref PackedFieldDescriptor d, T value)
       block = (block & ~mask) | ((encoded << valueBitOffset) & mask);
     }
 
-    private T Load(PackedTuple tuple, ref PackedFieldDescriptor d)
+    private T Load(PackedTuple tuple, in PackedFieldDescriptor d)
     {
       var valueIndex = d.ValueIndex;
       if (Rank > 6) {
diff --git a/Orm/Xtensive.Orm/Tuples/Packed/PackedTuple.cs b/Orm/Xtensive.Orm/Tuples/Packed/PackedTuple.cs
@@ -47,14 +47,14 @@ public override bool Equals(Tuple other)
       var count = Count;
       for (int i = 0; i < count; i++) {
         ref var descriptor = ref fieldDescriptors[i];
-        var thisState = GetFieldState(ref descriptor);
-        var otherState = packedOther.GetFieldState(ref descriptor);
+        var thisState = GetFieldState(descriptor);
+        var otherState = packedOther.GetFieldState(descriptor);
         if (thisState!=otherState)
           return false;
         if (thisState!=TupleFieldState.Available)
           continue;
         var accessor = descriptor.Accessor;
-        if (!accessor.ValueEquals(this, ref descriptor, packedOther, ref descriptor))
+        if (!accessor.ValueEquals(this, descriptor, packedOther, descriptor))
           return false;
       }
 
@@ -68,9 +68,9 @@ public override int GetHashCode()
       int result = 0;
       for (int i = 0; i < count; i++) {
         ref var descriptor = ref fieldDescriptors[i];
-        var state = GetFieldState(ref descriptor);
+        var state = GetFieldState(descriptor);
         var fieldHash = state == TupleFieldState.Available
-          ? descriptor.Accessor.GetValueHashCode(this, ref descriptor)
+          ? descriptor.Accessor.GetValueHashCode(this, descriptor)
           : 0;
         result = HashCodeMultiplier * result ^ fieldHash;
       }
@@ -79,7 +79,7 @@ public override int GetHashCode()
 
     public override TupleFieldState GetFieldState(int fieldIndex)
     {
-      return GetFieldState(ref PackedDescriptor.FieldDescriptors[fieldIndex]);
+      return GetFieldState(PackedDescriptor.FieldDescriptors[fieldIndex]);
     }
 
     protected internal override void SetFieldState(int fieldIndex, TupleFieldState fieldState)
@@ -94,7 +94,7 @@ protected internal override void SetFieldState(int fieldIndex, TupleFieldState f
     public override object GetValue(int fieldIndex, out TupleFieldState fieldState)
     {
       ref var descriptor = ref PackedDescriptor.FieldDescriptors[fieldIndex];
-      return descriptor.Accessor.GetUntypedValue(this, ref descriptor, out fieldState);
+      return descriptor.Accessor.GetUntypedValue(this, descriptor, out fieldState);
     }
 
     public override void SetValue(int fieldIndex, object fieldValue)
@@ -114,7 +114,7 @@ public void SetFieldState(ref PackedFieldDescriptor d, TupleFieldState fieldStat
       }
     }
 
-    public TupleFieldState GetFieldState(ref PackedFieldDescriptor d)
+    public TupleFieldState GetFieldState(in PackedFieldDescriptor d)
     {
       var block = Values[d.StateIndex];
       return (TupleFieldState) ((block >> d.StateBitOffset) & 3);
diff --git a/Orm/Xtensive.Orm/Tuples/Tuple.cs b/Orm/Xtensive.Orm/Tuples/Tuple.cs
@@ -112,13 +112,13 @@ public T GetValue<T>(int fieldIndex, out TupleFieldState fieldState)
 
       if (this is PackedTuple packedTuple) {
         ref var descriptor = ref packedTuple.PackedDescriptor.FieldDescriptors[fieldIndex];
-        return descriptor.Accessor.GetValue<T>(packedTuple, ref descriptor, isNullable, out fieldState);
+        return descriptor.Accessor.GetValue<T>(packedTuple, descriptor, isNullable, out fieldState);
       }
 
       var mappedContainer = GetMappedContainer(fieldIndex, false);
       if (mappedContainer.First is PackedTuple mappedTuple) {
         ref var descriptor = ref mappedTuple.PackedDescriptor.FieldDescriptors[mappedContainer.Second];
-        return descriptor.Accessor.GetValue<T>(mappedTuple, ref descriptor, isNullable, out fieldState);
+        return descriptor.Accessor.GetValue<T>(mappedTuple, descriptor, isNullable, out fieldState);
       }
 
       var value = GetValue(fieldIndex, out fieldState);
diff --git a/Orm/Xtensive.Orm/Tuples/TupleExtensions.cs b/Orm/Xtensive.Orm/Tuples/TupleExtensions.cs
@@ -438,7 +438,7 @@ private static void CopyPackedValue(PackedTuple source, int sourceIndex, PackedT
       ref var sourceDescriptor = ref source.PackedDescriptor.FieldDescriptors[sourceIndex];
       ref var targetDescriptor = ref target.PackedDescriptor.FieldDescriptors[targetIndex];
 
-      var fieldState = source.GetFieldState(ref sourceDescriptor);
+      var fieldState = source.GetFieldState(sourceDescriptor);
       if (!fieldState.IsAvailable()) {
         return;
       }

Original file line number	Diff line number	Diff line change
`@@ -47,32 +47,32 @@ public void SetValue<T>(PackedTuple tuple, ref PackedFieldDescriptor descriptor,`
`47`	`47`	`SetUntypedValue(tuple, ref descriptor, value);`
`48`	`48`	`}`
`49`	`49`
`50`		`- public T GetValue<T>(PackedTuple tuple, ref PackedFieldDescriptor descriptor, bool isNullable, out TupleFieldState fieldState)`
	`50`	`+ public T GetValue<T>(PackedTuple tuple, in PackedFieldDescriptor descriptor, bool isNullable, out TupleFieldState fieldState)`
`51`	`51`	`{`
`52`	`52`	`var getter = (isNullable ? NullableGetter : Getter) as GetValueDelegate<T>;`
`53`	`53`	`if (getter!=null)`
`54`		`- return getter.Invoke(tuple, ref descriptor, out fieldState);`
	`54`	`+ return getter.Invoke(tuple, descriptor, out fieldState);`
`55`	`55`	`var targetType = typeof (T);`
`56`	`56`
`57`	`57`	`//Dirty hack of nullable enum reading`
`58`	`58`	`if (isNullable)`
`59`	`59`	`targetType = Nullable.GetUnderlyingType(targetType) ?? targetType;`
`60`	`60`	`if (targetType.IsEnum)`
`61`		`- return (T) Enum.ToObject(targetType, GetUntypedValue(tuple, ref descriptor, out fieldState));`
`62`		`- return (T) GetUntypedValue(tuple, ref descriptor, out fieldState);`
	`61`	`+ return (T) Enum.ToObject(targetType, GetUntypedValue(tuple, descriptor, out fieldState));`
	`62`	`+ return (T) GetUntypedValue(tuple, descriptor, out fieldState);`
`63`	`63`	`}`
`64`	`64`
`65`		`- public abstract object GetUntypedValue(PackedTuple tuple, ref PackedFieldDescriptor descriptor, out TupleFieldState fieldState);`
	`65`	`+ public abstract object GetUntypedValue(PackedTuple tuple, in PackedFieldDescriptor descriptor, out TupleFieldState fieldState);`
`66`	`66`
`67`	`67`	`public abstract void SetUntypedValue(PackedTuple tuple, ref PackedFieldDescriptor descriptor, object value);`
`68`	`68`
`69`	`69`	`public abstract void CopyValue(PackedTuple source, ref PackedFieldDescriptor sourceDescriptor,`
`70`	`70`	`PackedTuple target, ref PackedFieldDescriptor targetDescriptor);`
`71`	`71`
`72`		`- public abstract bool ValueEquals(PackedTuple left, ref PackedFieldDescriptor leftDescriptor,`
`73`		`- PackedTuple right, ref PackedFieldDescriptor rightDescriptor);`
	`72`	`+ public abstract bool ValueEquals(PackedTuple left, in PackedFieldDescriptor leftDescriptor,`
	`73`	`+ PackedTuple right, in PackedFieldDescriptor rightDescriptor);`
`74`	`74`
`75`		`- public abstract int GetValueHashCode(PackedTuple tuple, ref PackedFieldDescriptor descriptor);`
	`75`	`+ public abstract int GetValueHashCode(PackedTuple tuple, in PackedFieldDescriptor descriptor);`
`76`	`76`
`77`	`77`	`protected PackedFieldAccessor(int rank, byte index)`
`78`	`78`	`{`
`@@ -101,9 +101,9 @@ protected PackedFieldAccessor(int rank, byte index)`
`101`	`101`
`102`	`102`	`internal sealed class ObjectFieldAccessor : PackedFieldAccessor`
`103`	`103`	`{`
`104`		`- public override object GetUntypedValue(PackedTuple tuple, ref PackedFieldDescriptor descriptor, out TupleFieldState fieldState)`
	`104`	`+ public override object GetUntypedValue(PackedTuple tuple, in PackedFieldDescriptor descriptor, out TupleFieldState fieldState)`
`105`	`105`	`{`
`106`		`- var state = tuple.GetFieldState(ref descriptor);`
	`106`	`+ var state = tuple.GetFieldState(descriptor);`
`107`	`107`	`fieldState = state;`
`108`	`108`	`return state==TupleFieldState.Available ? tuple.Objects[descriptor.ObjectIndex] : null;`
`109`	`109`	`}`
`@@ -123,15 +123,15 @@ public override void CopyValue(PackedTuple source, ref PackedFieldDescriptor sou`
`123`	`123`	`target.Objects[targetDescriptor.ObjectIndex] = source.Objects[sourceDescriptor.ObjectIndex];`
`124`	`124`	`}`
`125`	`125`
`126`		`- public override bool ValueEquals(PackedTuple left, ref PackedFieldDescriptor leftDescriptor,`
`127`		`- PackedTuple right, ref PackedFieldDescriptor rightDescriptor)`
	`126`	`+ public override bool ValueEquals(PackedTuple left, in PackedFieldDescriptor leftDescriptor,`
	`127`	`+ PackedTuple right, in PackedFieldDescriptor rightDescriptor)`
`128`	`128`	`{`
`129`	`129`	`var leftValue = left.Objects[leftDescriptor.ObjectIndex];`
`130`	`130`	`var rightValue = right.Objects[rightDescriptor.ObjectIndex];`
`131`	`131`	`return leftValue.Equals(rightValue);`
`132`	`132`	`}`
`133`	`133`
`134`		`- public override int GetValueHashCode(PackedTuple tuple, ref PackedFieldDescriptor descriptor)`
	`134`	`+ public override int GetValueHashCode(PackedTuple tuple, in PackedFieldDescriptor descriptor)`
`135`	`135`	`{`
`136`	`136`	`return tuple.Objects[descriptor.ObjectIndex].GetHashCode();`
`137`	`137`	`}`
`@@ -167,11 +167,11 @@ internal abstract class ValueFieldAccessor<T> : ValueFieldAccessor`
`167`	`167`
`168`	`168`	`protected virtual T Decode(long[] values, int offset) => throw new NotSupportedException();`
`169`	`169`
`170`		`- public override object GetUntypedValue(PackedTuple tuple, ref PackedFieldDescriptor descriptor, out TupleFieldState fieldState)`
	`170`	`+ public override object GetUntypedValue(PackedTuple tuple, in PackedFieldDescriptor descriptor, out TupleFieldState fieldState)`
`171`	`171`	`{`
`172`		`- var state = tuple.GetFieldState(ref descriptor);`
	`172`	`+ var state = tuple.GetFieldState(descriptor);`
`173`	`173`	`fieldState = state;`
`174`		`- return state==TupleFieldState.Available ? (object) Load(tuple, ref descriptor) : null;`
	`174`	`+ return state==TupleFieldState.Available ? (object) Load(tuple, descriptor) : null;`
`175`	`175`	`}`
`176`	`176`
`177`	`177`	`public override void SetUntypedValue(PackedTuple tuple, ref PackedFieldDescriptor descriptor, object value)`
`@@ -188,34 +188,34 @@ public override void SetUntypedValue(PackedTuple tuple, ref PackedFieldDescripto`
`188`	`188`	`public override void CopyValue(PackedTuple source, ref PackedFieldDescriptor sourceDescriptor,`
`189`	`189`	`PackedTuple target, ref PackedFieldDescriptor targetDescriptor)`
`190`	`190`	`{`
`191`		`- Store(target, ref targetDescriptor, Load(source, ref sourceDescriptor));`
	`191`	`+ Store(target, ref targetDescriptor, Load(source, sourceDescriptor));`
`192`	`192`	`}`
`193`	`193`
`194`		`- public override bool ValueEquals(PackedTuple left, ref PackedFieldDescriptor leftDescriptor,`
`195`		`- PackedTuple right, ref PackedFieldDescriptor rightDescriptor)`
	`194`	`+ public override bool ValueEquals(PackedTuple left, in PackedFieldDescriptor leftDescriptor,`
	`195`	`+ PackedTuple right, in PackedFieldDescriptor rightDescriptor)`
`196`	`196`	`{`
`197`		`- var leftValue = Load(left, ref leftDescriptor);`
`198`		`- var rightValue = Load(right, ref rightDescriptor);`
	`197`	`+ var leftValue = Load(left, leftDescriptor);`
	`198`	`+ var rightValue = Load(right, rightDescriptor);`
`199`	`199`	`return leftValue.Equals(rightValue);`
`200`	`200`	`}`
`201`	`201`
`202`		`- public override int GetValueHashCode(PackedTuple tuple, ref PackedFieldDescriptor descriptor)`
	`202`	`+ public override int GetValueHashCode(PackedTuple tuple, in PackedFieldDescriptor descriptor)`
`203`	`203`	`{`
`204`		`- return Load(tuple, ref descriptor).GetHashCode();`
	`204`	`+ return Load(tuple, descriptor).GetHashCode();`
`205`	`205`	`}`
`206`	`206`
`207`		`- private T GetValue(PackedTuple tuple, ref PackedFieldDescriptor descriptor, out TupleFieldState fieldState)`
	`207`	`+ private T GetValue(PackedTuple tuple, in PackedFieldDescriptor descriptor, out TupleFieldState fieldState)`
`208`	`208`	`{`
`209`		`- var state = tuple.GetFieldState(ref descriptor);`
	`209`	`+ var state = tuple.GetFieldState(descriptor);`
`210`	`210`	`fieldState = state;`
`211`		`- return state==TupleFieldState.Available ? Load(tuple, ref descriptor) : DefaultValue;`
	`211`	`+ return state==TupleFieldState.Available ? Load(tuple, descriptor) : DefaultValue;`
`212`	`212`	`}`
`213`	`213`
`214`		`- private T? GetNullableValue(PackedTuple tuple, ref PackedFieldDescriptor descriptor, out TupleFieldState fieldState)`
	`214`	`+ private T? GetNullableValue(PackedTuple tuple, in PackedFieldDescriptor descriptor, out TupleFieldState fieldState)`
`215`	`215`	`{`
`216`		`- var state = tuple.GetFieldState(ref descriptor);`
	`216`	`+ var state = tuple.GetFieldState(descriptor);`
`217`	`217`	`fieldState = state;`
`218`		`- return state==TupleFieldState.Available ? Load(tuple, ref descriptor) : NullValue;`
	`218`	`+ return state==TupleFieldState.Available ? Load(tuple, descriptor) : NullValue;`
`219`	`219`	`}`
`220`	`220`
`221`	`221`	`private void SetValue(PackedTuple tuple, ref PackedFieldDescriptor descriptor, T value)`
`@@ -249,7 +249,7 @@ private void Store(PackedTuple tuple, ref PackedFieldDescriptor d, T value)`
`249`	`249`	`block = (block & ~mask) \| ((encoded << valueBitOffset) & mask);`
`250`	`250`	`}`
`251`	`251`
`252`		`- private T Load(PackedTuple tuple, ref PackedFieldDescriptor d)`
	`252`	`+ private T Load(PackedTuple tuple, in PackedFieldDescriptor d)`
`253`	`253`	`{`
`254`	`254`	`var valueIndex = d.ValueIndex;`
`255`	`255`	`if (Rank > 6) {`
Original file line number	Diff line number	Diff line change
`@@ -47,14 +47,14 @@ public override bool Equals(Tuple other)`
`47`	`47`	`var count = Count;`
`48`	`48`	`for (int i = 0; i < count; i++) {`
`49`	`49`	`ref var descriptor = ref fieldDescriptors[i];`
`50`		`- var thisState = GetFieldState(ref descriptor);`
`51`		`- var otherState = packedOther.GetFieldState(ref descriptor);`
	`50`	`+ var thisState = GetFieldState(descriptor);`
	`51`	`+ var otherState = packedOther.GetFieldState(descriptor);`
`52`	`52`	`if (thisState!=otherState)`
`53`	`53`	`return false;`
`54`	`54`	`if (thisState!=TupleFieldState.Available)`
`55`	`55`	`continue;`
`56`	`56`	`var accessor = descriptor.Accessor;`
`57`		`- if (!accessor.ValueEquals(this, ref descriptor, packedOther, ref descriptor))`
	`57`	`+ if (!accessor.ValueEquals(this, descriptor, packedOther, descriptor))`
`58`	`58`	`return false;`
`59`	`59`	`}`
`60`	`60`
`@@ -68,9 +68,9 @@ public override int GetHashCode()`
`68`	`68`	`int result = 0;`
`69`	`69`	`for (int i = 0; i < count; i++) {`
`70`	`70`	`ref var descriptor = ref fieldDescriptors[i];`
`71`		`- var state = GetFieldState(ref descriptor);`
	`71`	`+ var state = GetFieldState(descriptor);`
`72`	`72`	`var fieldHash = state == TupleFieldState.Available`
`73`		`- ? descriptor.Accessor.GetValueHashCode(this, ref descriptor)`
	`73`	`+ ? descriptor.Accessor.GetValueHashCode(this, descriptor)`
`74`	`74`	`: 0;`
`75`	`75`	`result = HashCodeMultiplier * result ^ fieldHash;`
`76`	`76`	`}`
`@@ -79,7 +79,7 @@ public override int GetHashCode()`
`79`	`79`
`80`	`80`	`public override TupleFieldState GetFieldState(int fieldIndex)`
`81`	`81`	`{`
`82`		`- return GetFieldState(ref PackedDescriptor.FieldDescriptors[fieldIndex]);`
	`82`	`+ return GetFieldState(PackedDescriptor.FieldDescriptors[fieldIndex]);`
`83`	`83`	`}`
`84`	`84`
`85`	`85`	`protected internal override void SetFieldState(int fieldIndex, TupleFieldState fieldState)`
`@@ -94,7 +94,7 @@ protected internal override void SetFieldState(int fieldIndex, TupleFieldState f`
`94`	`94`	`public override object GetValue(int fieldIndex, out TupleFieldState fieldState)`
`95`	`95`	`{`
`96`	`96`	`ref var descriptor = ref PackedDescriptor.FieldDescriptors[fieldIndex];`
`97`		`- return descriptor.Accessor.GetUntypedValue(this, ref descriptor, out fieldState);`
	`97`	`+ return descriptor.Accessor.GetUntypedValue(this, descriptor, out fieldState);`
`98`	`98`	`}`
`99`	`99`
`100`	`100`	`public override void SetValue(int fieldIndex, object fieldValue)`
`@@ -114,7 +114,7 @@ public void SetFieldState(ref PackedFieldDescriptor d, TupleFieldState fieldStat`
`114`	`114`	`}`
`115`	`115`	`}`
`116`	`116`
`117`		`- public TupleFieldState GetFieldState(ref PackedFieldDescriptor d)`
	`117`	`+ public TupleFieldState GetFieldState(in PackedFieldDescriptor d)`
`118`	`118`	`{`
`119`	`119`	`var block = Values[d.StateIndex];`
`120`	`120`	`return (TupleFieldState) ((block >> d.StateBitOffset) & 3);`
Original file line number	Diff line number	Diff line change
`@@ -112,13 +112,13 @@ public T GetValue<T>(int fieldIndex, out TupleFieldState fieldState)`
`112`	`112`
`113`	`113`	`if (this is PackedTuple packedTuple) {`
`114`	`114`	`ref var descriptor = ref packedTuple.PackedDescriptor.FieldDescriptors[fieldIndex];`
`115`		`- return descriptor.Accessor.GetValue<T>(packedTuple, ref descriptor, isNullable, out fieldState);`
	`115`	`+ return descriptor.Accessor.GetValue<T>(packedTuple, descriptor, isNullable, out fieldState);`
`116`	`116`	`}`
`117`	`117`
`118`	`118`	`var mappedContainer = GetMappedContainer(fieldIndex, false);`
`119`	`119`	`if (mappedContainer.First is PackedTuple mappedTuple) {`
`120`	`120`	`ref var descriptor = ref mappedTuple.PackedDescriptor.FieldDescriptors[mappedContainer.Second];`
`121`		`- return descriptor.Accessor.GetValue<T>(mappedTuple, ref descriptor, isNullable, out fieldState);`
	`121`	`+ return descriptor.Accessor.GetValue<T>(mappedTuple, descriptor, isNullable, out fieldState);`
`122`	`122`	`}`
`123`	`123`
`124`	`124`	`var value = GetValue(fieldIndex, out fieldState);`
Original file line number	Diff line number	Diff line change
`@@ -438,7 +438,7 @@ private static void CopyPackedValue(PackedTuple source, int sourceIndex, PackedT`
`438`	`438`	`ref var sourceDescriptor = ref source.PackedDescriptor.FieldDescriptors[sourceIndex];`
`439`	`439`	`ref var targetDescriptor = ref target.PackedDescriptor.FieldDescriptors[targetIndex];`
`440`	`440`
`441`		`- var fieldState = source.GetFieldState(ref sourceDescriptor);`
	`441`	`+ var fieldState = source.GetFieldState(sourceDescriptor);`
`442`	`442`	`if (!fieldState.IsAvailable()) {`
`443`	`443`	`return;`
`444`	`444`	`}`