From 0128da4317e33074cde76e75614505d414ca8d7b Mon Sep 17 00:00:00 2001
From: "daniel.zeitlin" <daniel.zeitlin@eternix.co.il>
Date: Mon, 2 Jun 2014 11:05:05 +0300
Subject: [PATCH 1/7] - TypeUtil.IsStructImmutable() added, [JSImmutable] works
 with readonly/immutable structs with member methods (no MemberwiseClone()
 anymore) - Exception.GetType() implemented -
 JSIL.Array.FindIndex()/Find()/ForEach()/ConvertAll() implemented via proxy
 (support typed arrays) - Builtins.IsFalsy/IsTruthy() explicit case to object
 in parameter - Configuration.EmitAttributes list introduced (minimizes .js
 output substantially) - JSIL.Meta.dll made strong named - Float and Double
 +/-Infinity added via proxy

---
 JSIL/AssemblyTranslator.cs                    |  29 ++++++++++++-
 JSIL/Configuration.cs                         |   2 +
 .../StaticAnalysis/EmulateStructAssignment.cs |   2 +-
 JSIL/TypeUtil.cs                              |  11 +++++
 Libraries/JSIL.Bootstrap.js                   |   7 ++++
 Libraries/JSIL.Core.js                        |  39 ++++++++++++++++++
 Meta/Builtins.cs                              |   4 +-
 Meta/Meta.csproj                              |   9 ++++
 Meta/jsil.snk                                 | Bin 0 -> 596 bytes
 Proxies/Array.cs                              |  31 +++++++++++++-
 Proxies/Numbers.cs                            |  23 ++++++++++-
 11 files changed, 150 insertions(+), 7 deletions(-)
 create mode 100644 Meta/jsil.snk

diff --git a/JSIL/AssemblyTranslator.cs b/JSIL/AssemblyTranslator.cs
index 190ffd7da..f52f31f04 100644
--- a/JSIL/AssemblyTranslator.cs
+++ b/JSIL/AssemblyTranslator.cs
@@ -269,6 +269,20 @@ protected bool IsRedirected (string assemblyName) {
             return false;
         }
 
+        protected bool IsAttributeIgnored(string attributeName)
+        {
+          List<string> emitAttributes = Configuration.CodeGenerator.EmitAttributes;
+          if (emitAttributes.Count == 0)
+            return false;
+          foreach (var ia in emitAttributes)
+          {
+            if (Regex.IsMatch(attributeName, ia, RegexOptions.IgnoreCase))
+              return false;
+          }
+
+          return true;
+        }
+
         public string ClassifyAssembly (AssemblyDefinition asm) {
             if (IsIgnored(asm.FullName))
                 return "ignored";
@@ -2175,6 +2189,11 @@ where NeedsStaticConstructor(f.FieldType)
                         output.NewLine();
                         astEmitter.Visit(expr);
 
+                        //if (typedef.ToString() == "System.TimeSpan")
+                        //{
+                          //Console.WriteLine(fd.FullName); // detect TimeSpan.MaxValue issue
+                        //}
+
                         TranslateCustomAttributes(context, typedef, fd, astEmitter, output);
 
                         output.Semicolon(false);
@@ -2313,6 +2332,10 @@ private void TranslateCustomAttributes (
                 bool isFirst = true;
 
                 foreach (var attribute in member.CustomAttributes) {
+                    if (IsAttributeIgnored(attribute.AttributeType.FullName))
+                    {
+                      continue;
+                    }
                     if (!isFirst || standalone)
                         output.NewLine();
 
@@ -2356,10 +2379,14 @@ private void TranslateParameterAttributes (
             JavascriptAstEmitter astEmitter,
             JavascriptFormatter output
         ) {
+            if (!Configuration.CodeGenerator.EmitAllParameterNames.GetValueOrDefault(false))
+            {
+              return;
+            }
             output.Indent();
 
             foreach (var parameter in method.Parameters) {
-                if (!parameter.HasCustomAttributes && !Configuration.CodeGenerator.EmitAllParameterNames.GetValueOrDefault(false))
+                if (!parameter.HasCustomAttributes)
                     continue;
 
                 output.NewLine();
diff --git a/JSIL/Configuration.cs b/JSIL/Configuration.cs
index 4b9a94d57..278630a6e 100644
--- a/JSIL/Configuration.cs
+++ b/JSIL/Configuration.cs
@@ -46,6 +46,7 @@ public sealed class CodeGeneratorConfiguration {
             public bool? AutoGenerateEventAccessorsInSkeletons;
             public bool? AggressivelyUseElementProxies;
             public bool? EmitAllParameterNames;
+            public readonly List<string> EmitAttributes = new List<string>();
 
             public void MergeInto (CodeGeneratorConfiguration result) {
                 if (EliminateStructCopies.HasValue)
@@ -86,6 +87,7 @@ public void MergeInto (CodeGeneratorConfiguration result) {
                     result.AggressivelyUseElementProxies = AggressivelyUseElementProxies;
                 if (EmitAllParameterNames.HasValue)
                     result.EmitAllParameterNames = EmitAllParameterNames;
+                result.EmitAttributes.AddRange(EmitAttributes);
             }
         }
 
diff --git a/JSIL/Transforms/StaticAnalysis/EmulateStructAssignment.cs b/JSIL/Transforms/StaticAnalysis/EmulateStructAssignment.cs
index 8b036a61e..9e005978f 100644
--- a/JSIL/Transforms/StaticAnalysis/EmulateStructAssignment.cs
+++ b/JSIL/Transforms/StaticAnalysis/EmulateStructAssignment.cs
@@ -329,7 +329,7 @@ public void VisitNode (JSInvocationExpression invocation) {
                 //  before we call it.
                 var thisReferenceType = thisReference.GetActualType(TypeSystem);
 
-                if (TypeUtil.IsStruct(thisReferenceType)) {
+                if (TypeUtil.IsStruct(thisReferenceType) && !TypeUtil.IsStructImmutable(thisReferenceType)) {
                     if ((thisReference is JSVariable) || (thisReference is JSFieldAccess)) {
                         var rre = ParentNode as JSResultReferenceExpression;
                         var cloneExpr = new JSBinaryOperatorExpression(
diff --git a/JSIL/TypeUtil.cs b/JSIL/TypeUtil.cs
index 413e72bd8..4e8e4a897 100644
--- a/JSIL/TypeUtil.cs
+++ b/JSIL/TypeUtil.cs
@@ -96,6 +96,17 @@ public static bool IsStruct (TypeReference type) {
             return (etype == MetadataType.ValueType);
         }
 
+        public static bool IsStructImmutable(TypeReference type)
+        {
+          bool isImmutable = false;
+          TypeDefinition typeDef = type.Resolve();
+          if (typeDef.CustomAttributes.Count > 0)
+          {
+            isImmutable = typeDef.CustomAttributes.FirstOrDefault(ca => ca.AttributeType.FullName == "JSIL.Meta.JSImmutable") != null;
+          }
+          return isImmutable;
+        }
+
         public static bool IsNumeric (TypeReference type) {
             type = DereferenceType(type);
 
diff --git a/Libraries/JSIL.Bootstrap.js b/Libraries/JSIL.Bootstrap.js
index 56fb3be7f..2b0e641e0 100644
--- a/Libraries/JSIL.Bootstrap.js
+++ b/Libraries/JSIL.Bootstrap.js
@@ -539,6 +539,13 @@ JSIL.ImplementExternals(
       }
     );
 
+    $.Method({ Static: false, Public: true }, "GetType",
+      new JSIL.MethodSignature(mscorlib.TypeRef("System.Type"), []),
+      function () {
+        return this.__ThisType__;
+      }
+    );
+
     $.Method({Static: false, Public: true }, "toString",
       new JSIL.MethodSignature($.String, []),
       function () {
diff --git a/Libraries/JSIL.Core.js b/Libraries/JSIL.Core.js
index 969f4ff44..207991e24 100644
--- a/Libraries/JSIL.Core.js
+++ b/Libraries/JSIL.Core.js
@@ -8313,6 +8313,45 @@ JSIL.Array.ShallowCopy = function (destination, source) {
   JSIL.Array.CopyTo(source, destination, 0);
 };
 
+JSIL.Array.FindIndex = function (array, predicate) { // implements: int System.Array.FindIndex<T>(T[] array, Predicate<T> match)
+  for (var i = 0, l = array.length; i < l; i++) {
+    if (predicate(array[i]))
+      return i;
+  }
+  return -1;
+};
+
+JSIL.Array.Find = function (array, predicate) { // implements: T System.Array.Find<T>(T[] array, Predicate<T> match)
+  for (var i = 0, l = array.length; i < l; i++) {
+    if (predicate(array[i]))
+      return array[i];
+  }
+  return null; // use 'null' and not 'undefined'
+};
+
+JSIL.Array.ForEach = function (array, action) { // implements: void ForEach<T>(T[] array, Action<T> action)
+  if (JSIL.IsTypedArray(array)) {
+    for (var i = 0, l = array.length; i < l; i++) {
+      array[i] = action(array[i]);
+    }
+  }
+  else Array.prototype.forEach.call(array, action);
+};
+
+JSIL.Array.ConvertAll = function (array, converter) { // implements: TOutput[] ConvertAll<TInput, TOutput>(TInput[] array, Converter<TInput, TOutput> converter)
+  var cloned;
+  if (JSIL.IsTypedArray(array)) {
+    var ctor = Object.getPrototypeOf(array).constructor; // clone the typed array
+    cloned = new ctor(array);
+    for (var i = 0, l = cloned.length; i < l; i++) {
+      cloned[i] = converter(cloned[i]);
+    }
+  }
+  else cloned = Array.prototype.map.call(array, converter);
+
+  return cloned;
+};
+
 $jsilcore.CheckDelegateType = function (value) {
   if (value === null)
     return false;
diff --git a/Meta/Builtins.cs b/Meta/Builtins.cs
index dd8e94770..d93a835cd 100644
--- a/Meta/Builtins.cs
+++ b/Meta/Builtins.cs
@@ -54,11 +54,11 @@ public static T CreateNamedFunction<T> (
             throw new NotImplementedException("Not available outside JS");
         }
 
-        public static bool IsTruthy (dynamic value) {
+        public static bool IsTruthy (object valueExplicitCastToObject) {
             throw new NotImplementedException("Not available outside JS");
         }
 
-        public static bool IsFalsy (dynamic value) {
+        public static bool IsFalsy (object valueExplicitCastToObject) {
             throw new NotImplementedException("Not available outside JS");
         }
 
diff --git a/Meta/Meta.csproj b/Meta/Meta.csproj
index 3c892c00e..b666f7960 100644
--- a/Meta/Meta.csproj
+++ b/Meta/Meta.csproj
@@ -37,6 +37,12 @@
   <PropertyGroup>
     <ApplicationIcon>jsil.ico</ApplicationIcon>
   </PropertyGroup>
+  <PropertyGroup>
+    <SignAssembly>true</SignAssembly>
+  </PropertyGroup>
+  <PropertyGroup>
+    <AssemblyOriginatorKeyFile>jsil.snk</AssemblyOriginatorKeyFile>
+  </PropertyGroup>
   <ItemGroup>
     <Reference Include="System" />
     <Reference Include="System.Core" />
@@ -57,6 +63,9 @@
   <ItemGroup>
     <Content Include="jsil.ico" />
   </ItemGroup>
+  <ItemGroup>
+    <None Include="jsil.snk" />
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
diff --git a/Meta/jsil.snk b/Meta/jsil.snk
new file mode 100644
index 0000000000000000000000000000000000000000..c49a8755c240da6bc7cd7f9cf0ec41459aa09d4c
GIT binary patch
literal 596
zcmV-a0;~N80ssI2Bme+XQ$aES1ONa50098yTzHJdK_96oP@`!x@t_jm9<^VZ;&p^z
zjL#3%psLhaQ&wFYw&GT0Cl+YWpk1?=%j)R~PbGL%>L8I@C@O?+$E;y-g#A+t8dF#X
zc|scI%WzUhaiMsc!@hMUmxT2ZRBI;$i~Kt!hqo0a<RDPc3Ue;W3Tj^?M9FYSHdKv;
z*4?)DIY0MRX$_P6Dx0CN@P0aA^~1Vb2>f<~BuvMdjsiU##@<NlG%BPc@}nxV&ao9V
zW_E;orM&Rsa)!g<Dk--%SPqWlJ=X9^n6h&g$zC0#TCN>a*Xfwj;)B01CdxBp5Qb@G
zi81JCSrf0AJ+%2(BA#ZE1&)x*iVC?EJH5QNXpF8bf%}vZyOv_~0IQ{B`(4rxl&mZr
z%rG>nNO+S&A>!T;ucQDrZM3))MVldgYdUVv$M=mWseHnrlPR|HZn<R>QMrANW%vTY
zY0M<q4m1YmS@gaW^azE`{0@+Q?`n&7hfTU;0$*o^je)fHMzpf_Rts1Y9d0H>;0S?u
zO)`G?&i!EtSj-_ar&;~AblH%4(Q-+ny)v<4AbBm$h5iiIkHl>1=!=_ne5b^rvM2yw
zhr$KJLtmsJW8-)d+90oJ1P*<?FHX+VRGW^sLR9z=bt*wgbZa?f`_?LMZBnAoPQo0K
zhMSS#?8--0m+mOq)PAM&b9wK<xiQ3eMl}Uq_;HeT!aT|IbDD=lK>DSB=5H}2iq1v^
i!;5`ZT~v;+sh1f+!nU+SMkXB6^34}|A%xrk9cTktavGNa

literal 0
HcmV?d00001

diff --git a/Proxies/Array.cs b/Proxies/Array.cs
index 7d32bae95..a267f377a 100644
--- a/Proxies/Array.cs
+++ b/Proxies/Array.cs
@@ -75,6 +75,36 @@ public static int IndexOf<T> (T[] array, T value, int startIndex) {
             throw new InvalidOperationException();
         }
 
+        [JSReplacement("JSIL.Array.Find($array, $match)")]
+        public static T Find<T>(T[] array, Predicate<T> match)
+        {
+          throw new InvalidOperationException();
+        }
+
+        [JSReplacement("JSIL.Array.FindIndex($array, $match)")]
+        public static int FindIndex<T>(T[] array, Predicate<T> match)
+        {
+          throw new InvalidOperationException();
+        }
+
+        [JSReplacement("JSIL.Array.ForEach($array, $action)")]
+        public static void ForEach<T>(T[] array, Action<T> action)
+        {
+          throw new InvalidOperationException();
+        }
+
+        [JSReplacement("JSIL.Array.ConvertAll($array, $converter)")]
+        public static TOutput[] ConvertAll<TInput, TOutput>(TInput[] array, Converter<TInput, TOutput> converter)
+        {
+          throw new InvalidOperationException();
+        }
+
+        [JSReplacement("Array.prototype.every.call($array, $match)")]
+        public static bool TrueForAll<T>(T[] array, Predicate<T> match)
+        {
+          throw new InvalidOperationException();
+        }
+
         [JSReplacement("JSIL.Array.Clone($this)")]
         public object Clone () {
             throw new InvalidOperationException();
@@ -104,6 +134,5 @@ public static void Sort<T> (T[] array) {
         public System.Collections.IEnumerator GetEnumerator () {
             throw new InvalidOperationException();
         }
-
     }
 }
diff --git a/Proxies/Numbers.cs b/Proxies/Numbers.cs
index 32125ce70..3d27f415e 100644
--- a/Proxies/Numbers.cs
+++ b/Proxies/Numbers.cs
@@ -62,9 +62,28 @@ public string ToString (string format, IFormatProvider formatProvider) {
             throw new InvalidOperationException();
         }
 
+        [JSReplacement("!isFinite($value)")]
+        public static bool IsInfinity(NumberProxy value)
+        {
+          throw new InvalidOperationException();
+        }
+
         [JSReplacement("isNaN($value)")]
-        public static bool IsNaN (NumberProxy value) {
-            throw new InvalidOperationException();
+        public static bool IsNaN(NumberProxy value)
+        {
+          throw new InvalidOperationException();
+        }
+
+        [JSReplacement("($value == Infinity)")]
+        public static bool IsPositiveInfinity(NumberProxy value)
+        {
+          throw new InvalidOperationException();
+        }
+
+        [JSReplacement("($value == -Infinity)")]
+        public static bool IsNegativeInfinity(NumberProxy value)
+        {
+          throw new InvalidOperationException();
         }
 
         [JSIsPure]

From 5ee615855f8e2d5579777a88a491d01ba41356fc Mon Sep 17 00:00:00 2001
From: "daniel.zeitlin" <daniel.zeitlin@eternix.co.il>
Date: Mon, 2 Jun 2014 14:56:06 +0300
Subject: [PATCH 2/7] - prefer self-loops in JSIL.Array.ForEach() and
 JSIL.Array.ConvertAll() methods - AssemblyTranslator TimeSpan.MaxValue debug
 section removed, it's still bug, somehow TimeSpan.MaxValue/MinValue are not
 initialized

---
 JSIL/AssemblyTranslator.cs |  5 -----
 Libraries/JSIL.Core.js     | 20 ++++++--------------
 2 files changed, 6 insertions(+), 19 deletions(-)

diff --git a/JSIL/AssemblyTranslator.cs b/JSIL/AssemblyTranslator.cs
index f52f31f04..ebc777fa9 100644
--- a/JSIL/AssemblyTranslator.cs
+++ b/JSIL/AssemblyTranslator.cs
@@ -2189,11 +2189,6 @@ where NeedsStaticConstructor(f.FieldType)
                         output.NewLine();
                         astEmitter.Visit(expr);
 
-                        //if (typedef.ToString() == "System.TimeSpan")
-                        //{
-                          //Console.WriteLine(fd.FullName); // detect TimeSpan.MaxValue issue
-                        //}
-
                         TranslateCustomAttributes(context, typedef, fd, astEmitter, output);
 
                         output.Semicolon(false);
diff --git a/Libraries/JSIL.Core.js b/Libraries/JSIL.Core.js
index 207991e24..546d749a7 100644
--- a/Libraries/JSIL.Core.js
+++ b/Libraries/JSIL.Core.js
@@ -8330,25 +8330,17 @@ JSIL.Array.Find = function (array, predicate) { // implements: T System.Array.Fi
 };
 
 JSIL.Array.ForEach = function (array, action) { // implements: void ForEach<T>(T[] array, Action<T> action)
-  if (JSIL.IsTypedArray(array)) {
-    for (var i = 0, l = array.length; i < l; i++) {
-      array[i] = action(array[i]);
-    }
+  for (var i = 0, l = array.length; i < l; i++) {
+    array[i] = action(array[i]);
   }
-  else Array.prototype.forEach.call(array, action);
 };
 
 JSIL.Array.ConvertAll = function (array, converter) { // implements: TOutput[] ConvertAll<TInput, TOutput>(TInput[] array, Converter<TInput, TOutput> converter)
-  var cloned;
-  if (JSIL.IsTypedArray(array)) {
-    var ctor = Object.getPrototypeOf(array).constructor; // clone the typed array
-    cloned = new ctor(array);
-    for (var i = 0, l = cloned.length; i < l; i++) {
-      cloned[i] = converter(cloned[i]);
-    }
+  var ctor = Object.getPrototypeOf(array).constructor; // create the array (support typed array)
+  var cloned = new ctor(array.length);
+  for (var i = 0, l = array.length; i < l; i++) {
+    cloned[i] = converter(array[i]);
   }
-  else cloned = Array.prototype.map.call(array, converter);
-
   return cloned;
 };
 

From 265b5270e248f73492439aa88f09cf626f7d68dd Mon Sep 17 00:00:00 2001
From: "daniel.zeitlin" <daniel.zeitlin@eternix.co.il>
Date: Mon, 2 Jun 2014 15:30:38 +0300
Subject: [PATCH 3/7] - JSIL.Meta.dll strong naming reverted

---
 Meta/Meta.csproj |   9 ---------
 Meta/jsil.snk    | Bin 596 -> 0 bytes
 2 files changed, 9 deletions(-)
 delete mode 100644 Meta/jsil.snk

diff --git a/Meta/Meta.csproj b/Meta/Meta.csproj
index b666f7960..3c892c00e 100644
--- a/Meta/Meta.csproj
+++ b/Meta/Meta.csproj
@@ -37,12 +37,6 @@
   <PropertyGroup>
     <ApplicationIcon>jsil.ico</ApplicationIcon>
   </PropertyGroup>
-  <PropertyGroup>
-    <SignAssembly>true</SignAssembly>
-  </PropertyGroup>
-  <PropertyGroup>
-    <AssemblyOriginatorKeyFile>jsil.snk</AssemblyOriginatorKeyFile>
-  </PropertyGroup>
   <ItemGroup>
     <Reference Include="System" />
     <Reference Include="System.Core" />
@@ -63,9 +57,6 @@
   <ItemGroup>
     <Content Include="jsil.ico" />
   </ItemGroup>
-  <ItemGroup>
-    <None Include="jsil.snk" />
-  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
diff --git a/Meta/jsil.snk b/Meta/jsil.snk
deleted file mode 100644
index c49a8755c240da6bc7cd7f9cf0ec41459aa09d4c..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 596
zcmV-a0;~N80ssI2Bme+XQ$aES1ONa50098yTzHJdK_96oP@`!x@t_jm9<^VZ;&p^z
zjL#3%psLhaQ&wFYw&GT0Cl+YWpk1?=%j)R~PbGL%>L8I@C@O?+$E;y-g#A+t8dF#X
zc|scI%WzUhaiMsc!@hMUmxT2ZRBI;$i~Kt!hqo0a<RDPc3Ue;W3Tj^?M9FYSHdKv;
z*4?)DIY0MRX$_P6Dx0CN@P0aA^~1Vb2>f<~BuvMdjsiU##@<NlG%BPc@}nxV&ao9V
zW_E;orM&Rsa)!g<Dk--%SPqWlJ=X9^n6h&g$zC0#TCN>a*Xfwj;)B01CdxBp5Qb@G
zi81JCSrf0AJ+%2(BA#ZE1&)x*iVC?EJH5QNXpF8bf%}vZyOv_~0IQ{B`(4rxl&mZr
z%rG>nNO+S&A>!T;ucQDrZM3))MVldgYdUVv$M=mWseHnrlPR|HZn<R>QMrANW%vTY
zY0M<q4m1YmS@gaW^azE`{0@+Q?`n&7hfTU;0$*o^je)fHMzpf_Rts1Y9d0H>;0S?u
zO)`G?&i!EtSj-_ar&;~AblH%4(Q-+ny)v<4AbBm$h5iiIkHl>1=!=_ne5b^rvM2yw
zhr$KJLtmsJW8-)d+90oJ1P*<?FHX+VRGW^sLR9z=bt*wgbZa?f`_?LMZBnAoPQo0K
zhMSS#?8--0m+mOq)PAM&b9wK<xiQ3eMl}Uq_;HeT!aT|IbDD=lK>DSB=5H}2iq1v^
i!;5`ZT~v;+sh1f+!nU+SMkXB6^34}|A%xrk9cTktavGNa


From ca92e851799821df253eeef91de68ab267f9d259 Mon Sep 17 00:00:00 2001
From: "daniel.zeitlin" <daniel.zeitlin@eternix.co.il>
Date: Thu, 5 Jun 2014 01:22:42 +0300
Subject: [PATCH 4/7] - T Expression<T>(string javascript) introduced (save
 cast on return type, very useful) - Don't define (DeclaringType) on
 skipped/ignored attributes - TypeUtil.IsStructImmutable(TypeReference type)
 is more robust, all fields are 'readonly' -> struct is immutable, (much
 faster than: typeInfo = TypeInfo.GetTypeInformation(type) +
 typeInfo.IsImmutable)

---
 JSIL/AssemblyTranslator.cs | 12 ++++++++++++
 JSIL/ILBlockTranslator.cs  |  2 ++
 JSIL/TypeUtil.cs           |  9 +++++++--
 Meta/Verbatim.cs           | 28 +++++++++++++++++++++++-----
 4 files changed, 44 insertions(+), 7 deletions(-)

diff --git a/JSIL/AssemblyTranslator.cs b/JSIL/AssemblyTranslator.cs
index ebc777fa9..ee6c4d835 100644
--- a/JSIL/AssemblyTranslator.cs
+++ b/JSIL/AssemblyTranslator.cs
@@ -1057,6 +1057,18 @@ protected void DeclareType (
                 stubbed = true;
             }
 
+            bool isAttribute = false;
+            TypeInfo typeBaseClass = typeInfo.BaseClass;
+            while (!isAttribute && typeBaseClass != null)
+            {
+                isAttribute = (typeBaseClass.FullName == "System.Attribute");
+                typeBaseClass = typeBaseClass.BaseClass;
+            }
+            if (isAttribute && IsAttributeIgnored(typeInfo.FullName))
+            {
+                return;
+            }
+
             // This type is defined in JSIL.Core so we don't want to cause a name collision.
             if (!ShouldGenerateTypeDeclaration(typedef, makingSkeletons)) {
                 declaredTypes.Add(typedef);
diff --git a/JSIL/ILBlockTranslator.cs b/JSIL/ILBlockTranslator.cs
index 5a634b56f..ef534620a 100644
--- a/JSIL/ILBlockTranslator.cs
+++ b/JSIL/ILBlockTranslator.cs
@@ -555,6 +555,8 @@ protected JSExpression DoMethodReplacement (
                 case "System.Boolean JSIL.Builtins::IsFalsy(System.Object)":
                     return new JSUnaryOperatorExpression(JSOperator.LogicalNot, arguments.First(), TypeSystem.Boolean);
 
+                case "T JSIL.Verbatim::Expression(System.String)":
+                case "T JSIL.Verbatim::Expression(System.String,System.Object[])":
                 case "System.Object JSIL.Verbatim::Expression(System.String)":
                 case "System.Object JSIL.Verbatim::Expression(System.String,System.Object[])": {
                     var expression = arguments[0] as JSStringLiteral;
diff --git a/JSIL/TypeUtil.cs b/JSIL/TypeUtil.cs
index 4e8e4a897..8c0a157d1 100644
--- a/JSIL/TypeUtil.cs
+++ b/JSIL/TypeUtil.cs
@@ -96,14 +96,19 @@ public static bool IsStruct (TypeReference type) {
             return (etype == MetadataType.ValueType);
         }
 
-        public static bool IsStructImmutable(TypeReference type)
+        public static bool IsStructImmutable(TypeReference type) // much faster than: typeInfo = TypeInfo.GetTypeInformation(type) + typeInfo.IsImmutable
         {
           bool isImmutable = false;
           TypeDefinition typeDef = type.Resolve();
           if (typeDef.CustomAttributes.Count > 0)
-          {
+          { // check the attribute first
             isImmutable = typeDef.CustomAttributes.FirstOrDefault(ca => ca.AttributeType.FullName == "JSIL.Meta.JSImmutable") != null;
           }
+          if (!isImmutable)
+          { // all fields are read-only
+            isImmutable = typeDef.Fields.All(fd => fd.IsStatic || fd.IsInitOnly);
+          }
+
           return isImmutable;
         }
 
diff --git a/Meta/Verbatim.cs b/Meta/Verbatim.cs
index 3f5be2acb..fb4dfa349 100644
--- a/Meta/Verbatim.cs
+++ b/Meta/Verbatim.cs
@@ -1,9 +1,4 @@
 using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Linq;
-using System.Text;
-using JSIL.Meta;
 
 namespace JSIL {
     public static class Verbatim {
@@ -26,5 +21,28 @@ public static dynamic Expression (string javascript) {
         public static dynamic Expression (string javascript, params object[] variables) {
             return null;
         }
+
+        /// <summary>
+        /// When running as C#, this method does nothing and returns null.
+        /// When running as JavaScript, the passed-in script code replaces this method call.
+        /// </summary>
+        /// <param name="javascript">The script expression.</param>
+        /// <typeparam name="T">The return type.</typeparam>
+        public static T Expression<T>(string javascript) {
+          return default(T);
+        }
+
+        /// <summary>
+        /// When running as C#, this method does nothing and returns null.
+        /// When running as JavaScript, the passed-in script code replaces this method call.
+        /// Variables can be referenced by index. '$0' is the first variable.
+        /// </summary>
+        /// <param name="javascript">The script expression.</param>
+        /// <param name="variables">The variables to insert into the expression.</param>
+        /// <typeparam name="T">The return type.</typeparam>
+        public static T Expression<T>(string javascript, params object[] variables)
+        {
+          return default(T);
+        }
     }
 }

From d85d3623305ae29a5cc54673112241ef702f0e87 Mon Sep 17 00:00:00 2001
From: "daniel.zeitlin" <daniel.zeitlin@eternix.co.il>
Date: Sun, 8 Jun 2014 18:23:53 +0300
Subject: [PATCH 5/7] - [JSChangeEnumToNumber] attribute introduced to
 JSIL.Meta - int? CodeGeneratorConfiguration.ChangeEnumToNumber added, values
 are: 0 - disabled, 1 - with attribute only, 2 - all enums - TypeUtil.IsEnum()
 enhanced to report about enums to number change - Enums changed to number
 (Int32) implemented: generic parameter, default(Tenum), $Cast()

---
 JSIL/AST/JSExpressionTypes.cs           |  2 +-
 JSIL/AssemblyTranslator.cs              |  9 ++++++-
 JSIL/Configuration.cs                   |  3 +++
 JSIL/ILBlockTranslator.cs               |  2 +-
 JSIL/JavascriptAstEmitter.cs            | 27 ++++++++++++++++++---
 JSIL/JavascriptFormatter.cs             | 12 ++++++++++
 JSIL/Transforms/CacheTypeExpressions.cs |  3 +++
 JSIL/Transforms/IntroduceEnumCasts.cs   |  4 ++--
 JSIL/TypeUtil.cs                        | 31 +++++++++++++++++++++----
 Meta/Attributes.cs                      | 13 +++++++++++
 10 files changed, 94 insertions(+), 12 deletions(-)

diff --git a/JSIL/AST/JSExpressionTypes.cs b/JSIL/AST/JSExpressionTypes.cs
index d6a2a6e88..3045eefdd 100644
--- a/JSIL/AST/JSExpressionTypes.cs
+++ b/JSIL/AST/JSExpressionTypes.cs
@@ -1951,7 +1951,7 @@ internal static bool AllowBizarreReferenceCast (TypeReference currentType, TypeR
                     return true;
             }
 
-            if (TypeUtil.IsEnum(currentType) && TypeUtil.IsIntegral(newType))
+            if (TypeUtil.IsEnum(currentType) > 0 && TypeUtil.IsIntegral(newType))
                 return true;
 
             // Allow casting T*& to U*&
diff --git a/JSIL/AssemblyTranslator.cs b/JSIL/AssemblyTranslator.cs
index ee6c4d835..2f729fdcc 100644
--- a/JSIL/AssemblyTranslator.cs
+++ b/JSIL/AssemblyTranslator.cs
@@ -106,6 +106,8 @@ public AssemblyTranslator (
             Configuration = configuration;
             bool useDefaultProxies = configuration.UseDefaultProxies.GetValueOrDefault(true);
 
+            TypeUtil.s_ConfigurationChangeEnumToNumber = configuration.CodeGenerator.ChangeEnumToNumber.GetValueOrDefault(0);
+
             Manifest = manifest ?? new AssemblyManifest();
 
             if (typeInfoProvider != null) {
@@ -1135,6 +1137,11 @@ protected void DeclareType (
                     TranslateInterface(context, astEmitter, output, typedef);
                     return;
                 } else if (typedef.IsEnum) {
+                    if ((TypeUtil.IsEnum(typedef) & TypeUtil.EnumKind.ChangeToNumber) != 0)
+                    {
+                      return;
+                    }
+
                     output.Comment("enum {0}", Util.DemangleCecilTypeName(typedef.FullName));
                     output.NewLine();
                     output.NewLine();
@@ -2301,7 +2308,7 @@ private JSExpression TranslateAttributeConstructorArgument (
                 );
             } else if (ca.Type.FullName == "System.Type") {
                 return new JSTypeOfExpression((TypeReference)ca.Value);
-            } else if (TypeUtil.IsEnum(ca.Type)) {
+            } else if (TypeUtil.IsEnum(ca.Type) > 0) {
                 var longValue = Convert.ToInt64(ca.Value);
                 var result = JSEnumLiteral.TryCreate(
                     _TypeInfoProvider.GetExisting(ca.Type),
diff --git a/JSIL/Configuration.cs b/JSIL/Configuration.cs
index 278630a6e..0aca893e0 100644
--- a/JSIL/Configuration.cs
+++ b/JSIL/Configuration.cs
@@ -46,6 +46,7 @@ public sealed class CodeGeneratorConfiguration {
             public bool? AutoGenerateEventAccessorsInSkeletons;
             public bool? AggressivelyUseElementProxies;
             public bool? EmitAllParameterNames;
+            public int? ChangeEnumToNumber; // 0 - disabled, 1 - with attribute only, 2 - all enums
             public readonly List<string> EmitAttributes = new List<string>();
 
             public void MergeInto (CodeGeneratorConfiguration result) {
@@ -87,6 +88,8 @@ public void MergeInto (CodeGeneratorConfiguration result) {
                     result.AggressivelyUseElementProxies = AggressivelyUseElementProxies;
                 if (EmitAllParameterNames.HasValue)
                     result.EmitAllParameterNames = EmitAllParameterNames;
+                if (ChangeEnumToNumber.HasValue)
+                    result.ChangeEnumToNumber = ChangeEnumToNumber;
                 result.EmitAttributes.AddRange(EmitAttributes);
             }
         }
diff --git a/JSIL/ILBlockTranslator.cs b/JSIL/ILBlockTranslator.cs
index ef534620a..3d28fb921 100644
--- a/JSIL/ILBlockTranslator.cs
+++ b/JSIL/ILBlockTranslator.cs
@@ -354,7 +354,7 @@ protected JSExpression Translate_UnaryOp (ILExpression node, JSUnaryOperator op)
             }
 
             // Insert correct casts when unary operators are applied to enums.
-            if (TypeUtil.IsEnum(innerType) && TypeUtil.IsEnum(node.InferredType ?? node.ExpectedType)) {
+            if (TypeUtil.IsEnum(innerType) > 0 && TypeUtil.IsEnum(node.InferredType ?? node.ExpectedType) > 0) {
                 return JSCastExpression.New(
                     new JSUnaryOperatorExpression(
                         op,
diff --git a/JSIL/JavascriptAstEmitter.cs b/JSIL/JavascriptAstEmitter.cs
index 4e32df84e..94f7a1e54 100644
--- a/JSIL/JavascriptAstEmitter.cs
+++ b/JSIL/JavascriptAstEmitter.cs
@@ -435,6 +435,12 @@ public void VisitNode (JSAsExpression ae) {
         }
 
         public void VisitNode (JSCastExpression ce) {
+            if ((TypeUtil.IsEnum(ce.NewType) & TypeUtil.EnumKind.ChangeToNumber) != 0)
+            {
+              Visit(ce.Expression); // no cast here, since Enum changed to JS number
+              return;
+            }
+
             IncludeTypeParens.Push(false);
             try {
                 WritePossiblyCachedTypeIdentifier(ce.NewType, ce.CachedTypeIndex);
@@ -733,6 +739,20 @@ public void VisitNode (JSBooleanLiteral b) {
         }
 
         public void VisitNode (JSEnumLiteral enm) {
+            TypeUtil.EnumKind enumKind = TypeUtil.IsEnum(enm.EnumType);
+            if ((enumKind & TypeUtil.EnumKind.ChangeToNumber) != 0) {
+              if (enm.Names.Length == 1) {
+                Output.Comment(enm.EnumType.Name + "." + enm.Names[0]);
+              }
+              if ((enumKind & TypeUtil.EnumKind.FlagIsFlags) != 0) {
+                Output.WriteRaw("0x{0:X}", enm.Value);
+              }
+              else {
+                Output.Value(enm.Value);
+              }
+              return;
+            }
+
             if (enm.CachedEnumType != null)
                 Visit(enm.CachedEnumType);
             else
@@ -831,7 +851,7 @@ public void VisitNode (JSIgnoredTypeReference itr) {
         }
 
         public void VisitNode (JSDefaultValueLiteral defaultValue) {
-            if (TypeUtil.IsEnum(defaultValue.Value)) {
+            if ((TypeUtil.IsEnum(defaultValue.Value) & TypeUtil.EnumKind.IsEnum) != 0) {
                 EnumMemberInfo emi;
                 var enumInfo = TypeInfo.Get(defaultValue.Value);
                 
@@ -1517,8 +1537,9 @@ private bool NeedTruncationForBinaryOperator (JSBinaryOperatorExpression bop, Ty
         public void VisitNode (JSBinaryOperatorExpression bop) {
             var resultType = bop.GetActualType(TypeSystem);
 
+            TypeReference resultTypeStripped = TypeUtil.StripNullable(resultType);
             bool needsCast = (bop.Operator is JSArithmeticOperator) && 
-                TypeUtil.IsEnum(TypeUtil.StripNullable(resultType));
+                (TypeUtil.IsEnum(resultTypeStripped) & TypeUtil.EnumKind.IsEnum) != 0;
             bool needsTruncation = NeedTruncationForBinaryOperator(bop, resultType);
             bool parens = NeedParensForBinaryOperator(bop);
 
@@ -1526,7 +1547,7 @@ public void VisitNode (JSBinaryOperatorExpression bop) {
                 if (bop.Operator is JSAssignmentOperator)
                     throw new NotImplementedException("Truncation of assignment operations not implemented");
             } else if (needsCast) {
-                Output.Identifier(TypeUtil.StripNullable(resultType), ReferenceContext);
+                Output.Identifier(resultTypeStripped, ReferenceContext);
                 Output.WriteRaw(".$Cast");
             }
 
diff --git a/JSIL/JavascriptFormatter.cs b/JSIL/JavascriptFormatter.cs
index 267646b7f..0d697868e 100644
--- a/JSIL/JavascriptFormatter.cs
+++ b/JSIL/JavascriptFormatter.cs
@@ -700,6 +700,12 @@ public void TypeReference (TypeReference type, TypeReferenceContext context) {
                 }
             }
 
+            if ((TypeUtil.IsEnum(type) & TypeUtil.EnumKind.ChangeToNumber) != 0)
+            {
+              WriteRaw("$.Int32");
+              return;
+            }
+
             if (type.FullName == "JSIL.Proxy.AnyType") {
                 Value("JSIL.AnyType");
                 return;
@@ -857,6 +863,12 @@ protected void TypeIdentifier (TypeReference type, TypeReferenceContext context,
                     return;
                 }
 
+                if ((TypeUtil.IsEnum(type) & TypeUtil.EnumKind.ChangeToNumber) != 0)
+                {
+                  WriteRaw("$jsilcore.System.Int32");
+                  return;
+                }
+
                 var typedef = type.Resolve();
                 if (typedef != null) {
                     if (GetContainingAssemblyName(typedef) == Assembly.FullName) {
diff --git a/JSIL/Transforms/CacheTypeExpressions.cs b/JSIL/Transforms/CacheTypeExpressions.cs
index 0bc506568..9119e9c78 100644
--- a/JSIL/Transforms/CacheTypeExpressions.cs
+++ b/JSIL/Transforms/CacheTypeExpressions.cs
@@ -87,6 +87,9 @@ public bool IsCacheable (TypeReference type) {
             if (TypeUtil.IsOpenType(type))
                 return false;
 
+            if ((TypeUtil.IsEnum(type) & TypeUtil.EnumKind.ChangeToNumber) != 0)
+                return false;
+
             return true;
         }
 
diff --git a/JSIL/Transforms/IntroduceEnumCasts.cs b/JSIL/Transforms/IntroduceEnumCasts.cs
index c80458711..b68877900 100644
--- a/JSIL/Transforms/IntroduceEnumCasts.cs
+++ b/JSIL/Transforms/IntroduceEnumCasts.cs
@@ -79,7 +79,7 @@ public static JSExpression CastToEnumType (JSExpression value, TypeReference typ
         public static bool IsNullableEnum (TypeReference tr) {
             var git = tr as GenericInstanceType;
             if ((git != null) && (git.Name == "Nullable`1")) {
-                if (TypeUtil.IsEnum(git.GenericArguments[0]))
+                if ((TypeUtil.IsEnum(git.GenericArguments[0]) & TypeUtil.EnumKind.IsEnum) != 0)
                     return true;
             }
 
@@ -89,7 +89,7 @@ public static bool IsNullableEnum (TypeReference tr) {
         public static bool IsEnumOrNullableEnum (TypeReference tr) {
             tr = TypeUtil.DereferenceType(tr, false);
 
-            if (TypeUtil.IsEnum(tr))
+            if ((TypeUtil.IsEnum(tr) & TypeUtil.EnumKind.IsEnum) != 0)
                 return true;
 
             return IsNullableEnum(tr);
diff --git a/JSIL/TypeUtil.cs b/JSIL/TypeUtil.cs
index 8c0a157d1..2e0729d85 100644
--- a/JSIL/TypeUtil.cs
+++ b/JSIL/TypeUtil.cs
@@ -75,7 +75,7 @@ public static bool IsStruct (TypeReference type) {
             type = DereferenceType(type);
             MetadataType etype = type.MetadataType;
 
-            if (IsEnum(type))
+            if (IsEnum(type) > 0)
                 return false;
 
             var git = type as GenericInstanceType;
@@ -263,9 +263,32 @@ public static TypeReference StripNullable (TypeReference type) {
             return type;
         }
 
-        public static bool IsEnum (TypeReference type) {
-            var typedef = GetTypeDefinition(type);
-            return (typedef != null) && (typedef.IsEnum);
+        [Flags]
+        public enum EnumKind {
+          ChangeToNumber = 0x01,
+          IsEnum         = 0x02,
+
+          FlagIsFlags    = 0x04
+        };
+
+        internal static int s_ConfigurationChangeEnumToNumber = 0; // 0 - disabled, 1 - with attribute only, 2 - all enums
+
+        public static EnumKind IsEnum(TypeReference type) { // checks if type is Enum and should be converted to JS number
+          var typedef = GetTypeDefinition(type);
+          bool isEnum = (typedef != null) && typedef.IsEnum;
+          EnumKind result = 0;
+          if (isEnum)
+          {
+            var attributes = typedef.CustomAttributes;
+            result = (s_ConfigurationChangeEnumToNumber == 2) ||
+                     (s_ConfigurationChangeEnumToNumber > 0 &&
+                      attributes.Count > 0 &&
+                      attributes.Any(ca => ca.AttributeType.FullName == "JSIL.Meta.JSChangeEnumToNumber")) ? EnumKind.ChangeToNumber : EnumKind.IsEnum;
+            result |= (attributes.Count > 0 &&
+                       attributes.Any(ca => ca.AttributeType.FullName == "System.FlagsAttribute")) ? EnumKind.FlagIsFlags : 0;
+          }
+
+          return result;
         }
 
         public static bool IsBoolean (TypeReference type) {
diff --git a/Meta/Attributes.cs b/Meta/Attributes.cs
index ef26c604d..df0276d8e 100644
--- a/Meta/Attributes.cs
+++ b/Meta/Attributes.cs
@@ -101,6 +101,19 @@ public JSChangeToStaticMethod (string staticMethodName) {
         }
     }
 
+    /// <summary>
+    /// Specifies that uses of this enum should be replaced with corresponding number when translating code to javascript.
+    /// </summary>
+    [AttributeUsage(
+        AttributeTargets.Enum
+    )]
+    public sealed class JSChangeEnumToNumber : Attribute
+    {
+      public JSChangeEnumToNumber()
+      {
+      }
+    }
+
     /// <summary>
     /// Specifies that, if overloaded, the correct overload of this method to invoke should be decided at runtime instead of compile time.
     /// </summary>

From 1be20ea31fc361dcdea79028fda67a6fffc92ec2 Mon Sep 17 00:00:00 2001
From: "daniel.zeitlin" <daniel.zeitlin@eternix.co.il>
Date: Tue, 17 Jun 2014 13:54:42 +0300
Subject: [PATCH 6/7] - JSIL: BinaryWriter.Write(double) and Write(float)
 implemented

---
 Libraries/JSIL.IO.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Libraries/JSIL.IO.js b/Libraries/JSIL.IO.js
index c80468b39..2033dad73 100644
--- a/Libraries/JSIL.IO.js
+++ b/Libraries/JSIL.IO.js
@@ -885,7 +885,7 @@ JSIL.ImplementExternals("System.IO.BinaryWriter", function ($) {
   $.Method({Static:false, Public:true }, "Write", 
     (new JSIL.MethodSignature(null, [$.Double], [])), 
     function Write (value) {
-      throw new Error('Not implemented');
+      this.$writeBytes($jsilcore.BytesFromDouble(value));
     }
   );
 
@@ -934,7 +934,7 @@ JSIL.ImplementExternals("System.IO.BinaryWriter", function ($) {
   $.Method({Static:false, Public:true }, "Write", 
     (new JSIL.MethodSignature(null, [$.Single], [])), 
     function Write (value) {
-      throw new Error('Not implemented');
+      this.$writeBytes($jsilcore.BytesFromSingle(value));
     }
   );
 

From c9f35f3ff7826909d175a1e3aa76bbe780b9747d Mon Sep 17 00:00:00 2001
From: "daniel.zeitlin" <daniel.zeitlin@eternix.co.il>
Date: Tue, 8 Jul 2014 16:34:04 +0300
Subject: [PATCH 7/7] - IsStructImmutable more robust

---
 JSIL/TypeUtil.cs | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/JSIL/TypeUtil.cs b/JSIL/TypeUtil.cs
index 65c003260..0fe5c695e 100644
--- a/JSIL/TypeUtil.cs
+++ b/JSIL/TypeUtil.cs
@@ -100,7 +100,12 @@ public static bool IsStructImmutable(TypeReference type) // much faster than: ty
         {
           bool isImmutable = false;
           TypeDefinition typeDef = type.Resolve();
-          if (typeDef.CustomAttributes.Count > 0)
+          if (typeDef == null)
+          {
+            return false;
+          }
+          if (typeDef.CustomAttributes != null &&
+              typeDef.CustomAttributes.Count > 0)
           { // check the attribute first
             isImmutable = typeDef.CustomAttributes.FirstOrDefault(ca => ca.AttributeType.FullName == "JSIL.Meta.JSImmutable") != null;
           }