Merge remote-tracking branch 'upstream/master'

Author: hach-que

.gitignore

@@ -124,3 +124,5 @@ pingme.txt
 bin/
 obj/
 *.userprefs
+desktop.ini
+/httpd

Build/Projects/JSIL.Tests.definition

@@ -92,6 +92,7 @@
     <None Include="EmscriptenTestCases\PassPtrToPinnedArray.cs" />
     <None Include="AnalysisTestCases\Issue696.cs" />
     <None Include="EmscriptenTestCases\EnumRoundTrip.cs" />
+    <None Include="AnalysisTestCases\FNABaseOffset.cs" />
     <Compile Include="EmscriptenTestCases\ProxiedExternFunction.cs" />
     <None Include="EmscriptenTestCases\IntPtrZeroEquality.cs" />
     <None Include="EmscriptenTestCases\StringArrayParameter.cs" />
@@ -381,6 +382,7 @@
     <None Include="UnsafeTestCases\CastAddressOfValueToArray.cs" />
     <None Include="UnsafeTestCases\IgnorePointerFields.cs" />
     <None Include="UnsafeTestCases\PointerWriteConversion_Issue686.cs" />
+    <None Include="UnsafeTestCases\ModifyPackedStructArrayElementStructField.cs" />
     <Compile Include="XMLTests.cs" />
     <Compile Include="DependencyTests.cs" />
     <None Include="TestCases\GenericParameterNameShadowing.cs" />
@@ -599,4 +601,4 @@
     <Content Include="BinaryTestCases\InheritedAndExplicitOverwrittenMethods.dll" />
     <Content Include="BinaryTestCases\InheritedInterfacesExplicit.dll" />
   </Files>
-</Project>
+</Project>

Compiler/Profiles/ResourceConverter.cs

@@ -197,13 +197,14 @@ public static void ExtractFromAssembly (Configuration configuration, string asse
                 );
 
                 foreach (var kvp in manifestResources) {
-                    Console.WriteLine(kvp.Key);
                     var key = kvp.Key;
 
                     if (result.Files.ContainsKey(key)) {
                         if (result.Files[key].Size != kvp.Value.Length)
                             throw new InvalidOperationException("Found two conflicting manifest resources named '" + key + "'");
                     } else {
+                        Console.WriteLine(key);
+
                         result.AddFile(
                             "ManifestResource", key,
                             new ArraySegment<byte>(kvp.Value),

JSIL/AssemblyTranslator.cs

@@ -3051,9 +3051,11 @@ protected void DefineMethod (
 
                 TranslateOverrides(context, methodInfo.DeclaringType, method, methodInfo, astEmitter, output);
 
-                TranslateCustomAttributes(context, method.DeclaringType, method, astEmitter, output);
+                if (!makeSkeleton)
+                    TranslateCustomAttributes(context, method.DeclaringType, method, astEmitter, output);
 
-                TranslateParameterAttributes(context, method.DeclaringType, method, astEmitter, output);
+                if (!makeSkeleton)
+                    TranslateParameterAttributes(context, method.DeclaringType, method, astEmitter, output);
 
                 output.Semicolon();
             } finally {

JSIL/FunctionCache.cs

@@ -183,7 +183,7 @@ private static bool TryAcquireStaticAnalysisDataLock (Entry entry, QualifiedMemb
             return true;
         }
 
-        public FunctionAnalysis1stPass GetFirstPass (QualifiedMemberIdentifier method, QualifiedMemberIdentifier forMethod) {
+        public FunctionAnalysis1stPass GetFirstPass (QualifiedMemberIdentifier method, QualifiedMemberIdentifier forCaller) {
             var entry = GetCacheEntry(method, false);
 
             if ((entry == null) || (entry.Expression == null))
@@ -217,7 +217,11 @@ private FunctionAnalysis2ndPass _GetOrCreateSecondPass (Entry entry) {
                 (entry.SecondPass == null) && 
                 (entry.Expression != null)
             ) {
-                if (entry.Definition.IsAbstract)
+                if (
+                    entry.Definition.IsAbstract ||
+                    // HACK: Fixes ExpressionsExecution and ExpressionsTest???
+                    (entry.FirstPass == null)
+                )
                     entry.SecondPass = CreateSecondPassForAbstractMethod(entry.Info);
                 else if (entry.Definition.IsVirtual)
                     entry.SecondPass = CreateSecondPassForOverridableMethod(entry.Info, entry.FirstPass);
@@ -228,7 +232,7 @@ private FunctionAnalysis2ndPass _GetOrCreateSecondPass (Entry entry) {
             return entry.SecondPass;
         }
 
-        public FunctionAnalysis2ndPass GetSecondPass (JSMethod method, QualifiedMemberIdentifier forMethod) {
+        public FunctionAnalysis2ndPass GetSecondPass (JSMethod method, QualifiedMemberIdentifier forCaller) {
             if (method == null)
                 return null;
 
@@ -240,7 +244,7 @@ public FunctionAnalysis2ndPass GetSecondPass (JSMethod method, QualifiedMemberId
             if (entry == null)
                 return null;
 
-            GetFirstPass(id, forMethod);
+            GetFirstPass(id, forCaller);
 
             if (!TryAcquireStaticAnalysisDataLock(entry, method.QualifiedIdentifier))
                 return null;

JSIL/FunctionTransformPipeline.cs

@@ -88,23 +88,12 @@ public TypeInfoProvider TypeInfoProvider {
         private bool RunStaticAnalysisDependentTransform<T> (T visitor, Action<T> postVisitAction = null)
             where T : StaticAnalysisJSAstVisitor 
         {
-            try {
-                visitor.Visit(Function);
-
-                if (postVisitAction != null)
-                    postVisitAction(visitor);
+            visitor.Visit(Function);
 
-                return true;
-            } catch (TemporarilySuspendTransformPipelineException exc) {
-                if (Trace)
-                    Console.WriteLine(
-                        "Static analysis for '{2}::{3}' suspended due to dependency on '{0}::{1}'", 
-                        exc.Identifier.Type.Name, exc.Identifier.Member.Name, 
-                        Identifier.Type.Name, Identifier.Member.Name
-                    );
+            if (postVisitAction != null)
+                postVisitAction(visitor);
 
-                return false;
-            }
+            return true;
         }
 
         public void Enqueue (FunctionTransformPipelineStage stage) {
@@ -131,7 +120,22 @@ public bool RunUntilCompletion () {
                     var currentStage = Pipeline.Peek();
 
                     try {
-                        if (currentStage()) {
+                        var stageSucceeded = false;
+
+                        try {
+                            stageSucceeded = currentStage();
+                        } catch (TemporarilySuspendTransformPipelineException exc) {
+                            if (Trace)
+                                Console.WriteLine(
+                                    "Static analysis for '{2}::{3}' suspended due to dependency on '{0}::{1}'", 
+                                    exc.Identifier.Type.Name, exc.Identifier.Member.Name, 
+                                    Identifier.Type.Name, Identifier.Member.Name
+                                );
+
+                            return false;
+                        }
+
+                        if (stageSucceeded) {
                             Pipeline.Dequeue();
 
                             if (CheckForStaticAnalysisChanges) {

JSIL/Transforms/StaticAnalysis/EmulateStructAssignment.cs

@@ -176,13 +176,17 @@ protected bool IsCopyNeeded (
 
             var valueDot = value as JSDotExpressionBase;
 
-            // The value is being read out of an element proxy, so no copy is necessary - the read unpacks the value
-            //  on demand from the packed array.
+            // The value is being read out of an element proxy
             if (
                 (valueDot != null) &&
                 PackedArrayUtil.IsElementProxy(valueDot.Target)
             ) {
+                // BROKEN: no copy is necessary - the read unpacks the value on demand from the packed array.
                 // return false;
+
+                // HACK: Currently struct fields are proxies so that writes to them work correctly.
+                // FIXME: Maybe return true here always?
+                // return true;
             }
 
             var valueTypeInfo = TypeInfo.GetExisting(valueType);
@@ -482,6 +486,31 @@ private bool IsVarEffectivelyConstantHere (JSVariable variable) {
             return false;
         }
 
+        private bool IsStructVariableNeverMutated (JSExpression expr) {
+            var variable = expr as JSVariable;
+
+            if (variable == null)
+                return false;
+
+            // FIXME: ref/out don't generate a SideEffect. Should they?
+            // I think reassignment through ref/out is safe but mutation through
+            //  them is not safe. On the other hand, ref/out vars should always
+            //  generate a copy on read... right?
+
+            if (SecondPass == null)
+                return false;
+            else if (SecondPass.IndirectSideEffectVariables.Contains(variable.Name))
+                return false;
+            else if (SecondPass.Data == null)
+                return false;
+
+            foreach (var se in SecondPass.Data.SideEffects)
+                if (se.Variable == variable.Name)
+                    return false;
+
+            return true;
+        }
+
         public void VisitNode (JSBinaryOperatorExpression boe) {
             if (boe.Operator != JSOperator.Assignment) {
                 base.VisitNode(boe);
@@ -498,15 +527,20 @@ public void VisitNode (JSBinaryOperatorExpression boe) {
                 // Even if the assignment target is never modified, if the assignment *source*
                 //  gets modified, we need to make a copy here, because the target is probably
                 //  being used as a back-up copy.
-                var rightVarsModified = (rightVars.Any((rv) => SecondPass.IsVariableModified(rv.Name)));
+                var rightVarsMutated = rightVars.Any((rv) => !IsStructVariableNeverMutated(rv));
                 var rightVarsAreReferences = rightVars.Any((rv) => rv.IsReference);
 
+                // We need to ensure that the lhs is never mutated. Reassignment is fine.
+                bool leftVarMutated = !IsStructVariableNeverMutated(boe.Left);
+
                 bool rightVarIsEffectivelyConstantHere = 
-                    IsVarEffectivelyConstantHere(boe.Right as JSVariable);
+                    IsVarEffectivelyConstantHere(boe.Right as JSVariable) &&
+                    !leftVarMutated;
 
                 if (
                     (
-                        rightVarsModified || 
+                        rightVarsMutated || 
+                        leftVarMutated ||
                         IsCopyNeededForAssignmentTarget(boe.Left) || 
                         rightVarsAreReferences
                     ) &&
@@ -522,7 +556,9 @@ public void VisitNode (JSBinaryOperatorExpression boe) {
                     if (TraceElidedCopies) {
                         Console.WriteLine(
                             "struct copy elided for assignment {0} = {1}{2}", boe.Left, boe.Right,
-                            rightVarIsEffectivelyConstantHere ? " (rhs is effectively constant due to following all other accesses)" : ""
+                            rightVarIsEffectivelyConstantHere 
+                                ? " (rhs is effectively constant due to following all other accesses)" 
+                                : ""
                         );
                     }
                 }

JSIL/Transforms/StaticAnalysis/StaticAnalyzer.cs

@@ -266,9 +266,10 @@ public void VisitNode (JSFieldAccess fa) {
                     parentNodeIndices, StatementIndex, NodeIndex, field.Field.DeclaringType
                 ));
             } else if (v != null) {
-                State.SideEffects.Add(new FunctionAnalysis1stPass.SideEffect(
-                    parentNodeIndices, StatementIndex, NodeIndex, v.Identifier, "field modified"
-                ));
+                if (fa.IsWrite)
+                    State.SideEffects.Add(new FunctionAnalysis1stPass.SideEffect(
+                        parentNodeIndices, StatementIndex, NodeIndex, v.Identifier, "field modified"
+                    ));
             }
 
             bool isRead = true;
@@ -403,7 +404,7 @@ public void VisitNode (JSInvocationExpression ie) {
                 ));
 
                 // HACK: Synthesize an assignment record for direct invocations of constructors on struct locals
-                if ((method) != null && (method.Method.Name == ".ctor")) {
+                if ((method != null) && (method.Method.Name == ".ctor")) {
                     var t = thisVar.GetActualType(TypeSystem);
                     var synthesizedAssignment = new FunctionAnalysis1stPass.Assignment(
                         pni, StatementIndex, NodeIndex, thisVar.Name,
@@ -749,6 +750,7 @@ public class FunctionAnalysis2ndPass {
         public readonly HashSet<HashSet<FieldInfo>> RecursivelyMutatedFields;
         private readonly HashSet<string> ModifiedVariables;
         private readonly HashSet<string> EscapingVariables;
+        public readonly HashSet<string> IndirectSideEffectVariables;
         public readonly string ResultVariable;
         public readonly bool ResultIsNew;
         public readonly bool ViolatesThisReferenceImmutability;
@@ -768,6 +770,15 @@ bool isSealed
             Data = data;
             IsSealed = isSealed;
 
+            if (data == null)
+                throw new ArgumentNullException("data");
+            else if (data.Function == null)
+                throw new ArgumentNullException("data.Function");
+            else if (data.Function.Method == null)
+                throw new ArgumentNullException("data.Function.Method");
+            else if (data.Function.Method.Method == null)
+                throw new ArgumentNullException("data.Function.Method.Method");
+
             if (data.Function.Method.Method.Metadata.HasAttribute("JSIsPure"))
                 _IsPure = true;
             else
@@ -940,14 +951,60 @@ from p in data.Function.Parameters select p.Name
             }
 
             if (
-                !data.Function.Method.Method.IsStatic && 
-                data.Function.Method.Method.DeclaringType.IsImmutable &&
-                data.ReassignsThisReference
+                (
+                    !data.Function.Method.Method.IsStatic && 
+                    data.Function.Method.Method.DeclaringType.IsImmutable &&
+                    data.ReassignsThisReference
+                ) ||
+                data.Function.Method.Method.Name == ".ctor"
             ) {
                 ViolatesThisReferenceImmutability = true;
                 ModifiedVariables.Add("this");
             }
 
+            IndirectSideEffectVariables = new HashSet<string>();
+
+            // Invocations that reassign or mutate this need to have a synthesized side effect
+            foreach (var invocation in data.Invocations) {
+                if (invocation.ThisVariable == null)
+                    continue;
+                else if (IndirectSideEffectVariables.Contains(invocation.ThisVariable))
+                    continue;
+
+                bool shouldSynthesizeSideEffect = false;
+                do {
+                    var jsm = invocation.Method;
+                    if (jsm == null) {
+                        shouldSynthesizeSideEffect = true;
+                        break;
+                    }
+
+                    var targetSecondPass = functionCache.GetSecondPass(invocation.Method, data.Identifier);
+                    if (targetSecondPass == null) {
+                        shouldSynthesizeSideEffect = true;
+                        break;
+                    }
+
+                    if (targetSecondPass.ViolatesThisReferenceImmutability) {
+                        shouldSynthesizeSideEffect = true;
+                        break;
+                    } else if (
+                        (targetSecondPass.Data != null) && 
+                        targetSecondPass.Data.SideEffects.Any(se => se.Variable == "this")
+                    ) {
+                        // FIXME: Is this necessary or is it overly conservative?
+                        shouldSynthesizeSideEffect = true;
+                        break;
+                    }
+
+                    if (!shouldSynthesizeSideEffect)
+                        ;
+                } while (false);
+
+                if (shouldSynthesizeSideEffect)
+                    IndirectSideEffectVariables.Add(invocation.ThisVariable);
+            }
+
             MutatedFields = new HashSet<FieldInfo>(
                 from fa in data.FieldAccesses where !fa.IsRead select fa.Field.Field
             );
@@ -1006,12 +1063,15 @@ public FunctionAnalysis2ndPass (FunctionCache functionCache, MethodInfo method)
             }
 
             VariableAliases = new Dictionary<string, HashSet<string>>();
+            IndirectSideEffectVariables = new HashSet<string>();
 
             ResultVariable = null;
             ResultIsNew = method.Metadata.HasAttribute("JSIL.Meta.JSResultIsNew");
 
             MutatedFields = null;
 
+            ViolatesThisReferenceImmutability = (method.Name == ".ctor");
+
             Trace(method.Member.FullName);
         }
 

LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2011-2015 Katelyn Gadd
+Some sponsored contributions (c) Mozilla Corporation
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

Libraries/JSIL.Bootstrap.js

@@ -4545,6 +4545,9 @@ $jsilcore.GetSerializationScratchBuffers = function () {
         offset = offset | 0;
         count = count | 0;
 
+        if (!bytes)
+          JSIL.RuntimeError("bytes cannot be null");
+
         for (var i = 0; i < count; i++)
           this.uint8[i] = bytes[offset + i];
       }