Merge remote-tracking branch 'upstream/master'

Author: hach-que

Build/Projects/JSIL.Tests.definition

@@ -93,6 +93,8 @@
     <None Include="AnalysisTestCases\Issue696.cs" />
     <None Include="EmscriptenTestCases\EnumRoundTrip.cs" />
     <None Include="AnalysisTestCases\FNABaseOffset.cs" />
+    <None Include="EmscriptenTestCases\OutUnionParameter.cs" />
+    <None Include="EmscriptenTestCases\OutComplexUnionParameter.cs" />
     <Compile Include="EmscriptenTestCases\ProxiedExternFunction.cs" />
     <None Include="EmscriptenTestCases\IntPtrZeroEquality.cs" />
     <None Include="EmscriptenTestCases\StringArrayParameter.cs" />
@@ -383,6 +385,10 @@
     <None Include="UnsafeTestCases\IgnorePointerFields.cs" />
     <None Include="UnsafeTestCases\PointerWriteConversion_Issue686.cs" />
     <None Include="UnsafeTestCases\ModifyPackedStructArrayElementStructField.cs" />
+    <None Include="UnsafeTestCases\CustomPacking.cs" />
+    <None Include="UnsafeTestCases\CustomFieldOffset.cs" />
+    <None Include="UnsafeTestCases\CustomFieldOffsetUnion.cs" />
+    <None Include="UnsafeTestCases\UnionContainingEnum.cs" />
     <Compile Include="XMLTests.cs" />
     <Compile Include="DependencyTests.cs" />
     <None Include="TestCases\GenericParameterNameShadowing.cs" />

JSIL/AST/JSExpressionTypes.cs

@@ -1608,12 +1608,14 @@ public class JSMemberDescriptor : JSExpression {
         public readonly bool IsStatic;
         public readonly bool IsVirtual;
         public readonly bool IsReadonly;
+        public readonly int? Offset;
 
-        public JSMemberDescriptor (bool isPublic, bool isStatic, bool isVirtual = false, bool isReadonly = false) {
+        public JSMemberDescriptor (bool isPublic, bool isStatic, bool isVirtual = false, bool isReadonly = false, int? offset = null) {
             IsPublic = isPublic;
             IsStatic = isStatic;
             IsVirtual = isVirtual;
             IsReadonly = isReadonly;
+            Offset = offset;
         }
 
         public override bool IsConstant {

JSIL/AssemblyTranslator.cs

@@ -1480,6 +1480,32 @@ protected void DeclareType (
                         output.NewLine();
                     }
 
+                    if (typedef.IsExplicitLayout) {
+                        output.WriteRaw("ExplicitLayout: true");
+                        output.Comma();
+                        output.NewLine();
+                    } else if (typedef.IsSequentialLayout) {
+                        output.WriteRaw("SequentialLayout: true");
+                        output.Comma();
+                        output.NewLine();
+                    }
+
+                    if (typedef.HasLayoutInfo) {
+                        if (typedef.PackingSize != 0) {
+                            output.WriteRaw("Pack: ");
+                            output.Value(typedef.PackingSize);
+                            output.Comma();
+                            output.NewLine();
+                        }
+
+                        if (typedef.ClassSize != 0) {
+                            output.WriteRaw("SizeBytes: ");
+                            output.Value(typedef.ClassSize);
+                            output.Comma();
+                            output.NewLine();
+                        }
+                    }
+
                     output.CloseBrace(false);
                 }
 
@@ -2119,7 +2145,11 @@ protected JSExpression TranslateField (
 
             var dollarIdentifier = new JSRawOutputIdentifier(field.DeclaringType, dollar.Format, dollar.Arguments);
             var descriptor = new JSMemberDescriptor(
-                field.IsPublic, field.IsStatic, isReadonly: field.IsInitOnly
+                field.IsPublic, field.IsStatic, 
+                isReadonly: field.IsInitOnly, 
+                offset: field.DeclaringType.IsExplicitLayout
+                    ? (int?)field.Offset
+                    : null
             );
 
             var fieldName = Util.EscapeIdentifier(fieldInfo.Name, EscapingMode.MemberIdentifier);

JSIL/ILBlockTranslator.cs

@@ -1129,28 +1129,42 @@ public JSExpression TranslateNode (ILExpression expression) {
                 (expression.InferredType != null) &&
                 !TypeUtil.TypesAreAssignable(TypeInfo, expression.ExpectedType, expression.InferredType)
             ) {
+                var expectedType = expression.ExpectedType;
+
                 // HACK: Expected types inside of comparison expressions are wrong, so we need to suppress
                 //  the casts they would normally generate sometimes.
                 bool shouldAutoCast = (
                     AutoCastingState.Peek() ||
                     (
                         // Comparisons between value types still need a cast.
-                        !TypeUtil.IsReferenceType(expression.ExpectedType) || 
+                        !TypeUtil.IsReferenceType(expectedType) || 
                         !TypeUtil.IsReferenceType(expression.InferredType)
                     )
                 );
 
+                // HACK: ILSpy improperly decompiles sequences like:
+                // byte * px = ...;
+                // *((A*)px) = new A()
+                // into a cast of the form ((A&)px) = new A()
+                if (
+                    (expectedType is ByReferenceType) &&
+                    (expression.InferredType is PointerType) &&
+                    !TypeUtil.TypesAreEqual(expectedType.GetElementType(), expression.InferredType.GetElementType())
+                ) {
+                    expectedType = new PointerType(expectedType.GetElementType());
+                }
+
                 bool specialNullableCast = (
-                    TypeUtil.IsNullable(expression.ExpectedType) ||
+                    TypeUtil.IsNullable(expectedType) ||
                     TypeUtil.IsNullable(expression.InferredType) ||
                     (expression.Code == ILCode.ValueOf)
                 );
 
                 if (shouldAutoCast) {
                     if (specialNullableCast)
-                        return new JSNullableCastExpression(result, new JSType(expression.ExpectedType));
+                        return new JSNullableCastExpression(result, new JSType(expectedType));
                     else
-                        return JSCastExpression.New(result, expression.ExpectedType, TypeSystem, isCoercion: true);
+                        return JSCastExpression.New(result, expectedType, TypeSystem, isCoercion: true);
                 } else {
                     // FIXME: Should this be JSChangeTypeExpression to preserve type information?
                     // I think not, because a lot of these ExpectedTypes are wrong.

JSIL/JavascriptAstEmitter.cs

@@ -2062,7 +2062,7 @@ public void VisitNode (JSArrayExpression array) {
         }
 
         public void VisitNode (JSMemberDescriptor desc) {
-            Output.MemberDescriptor(desc.IsPublic, desc.IsStatic, desc.IsVirtual, desc.IsReadonly);
+            Output.MemberDescriptor(desc.IsPublic, desc.IsStatic, desc.IsVirtual, desc.IsReadonly, desc.Offset);
         }
 
         public void VisitNode (JSObjectExpression obj) {

JSIL/JavascriptFormatter.cs

@@ -743,7 +743,11 @@ public void TypeReference (TypeInfo type, TypeReferenceContext context) {
             TypeReference(type.Definition, context);
         }
 
-        public void MemberDescriptor (bool isPublic, bool isStatic, bool isVirtual = false, bool isReadonly = false) {
+        public void MemberDescriptor (
+            bool isPublic, bool isStatic, 
+            bool isVirtual = false, bool isReadonly = false,
+            int? offset = null
+        ) {
             WriteRaw("{");
 
             WriteRaw("Static");
@@ -776,6 +780,13 @@ public void MemberDescriptor (bool isPublic, bool isStatic, bool isVirtual = fal
                 WriteRaw("true ");
             }
 
+            if (offset.HasValue) {
+                Comma();
+
+                WriteRaw("Offset: ");
+                Value(offset.Value);
+            }
+
             WriteRaw("}");
         }
 

Libraries/JSIL.Bootstrap.js

@@ -4537,7 +4537,7 @@ $jsilcore.GetSerializationScratchBuffers = function () {
 
         var result = new Uint8Array(byteCount);
         for (var i = 0; i < byteCount; i++)
-          result[i] = this.uint8[i];
+          result[i] = uint8[i];
 
         return result;
       },
@@ -4549,7 +4549,7 @@ $jsilcore.GetSerializationScratchBuffers = function () {
           JSIL.RuntimeError("bytes cannot be null");
 
         for (var i = 0; i < count; i++)
-          this.uint8[i] = bytes[offset + i];
+          uint8[i] = bytes[offset + i];
       }
     };
   }