Some test cases.

src/avm2/compiler/inferrer.js

@@ -856,7 +856,7 @@ var Verifier = (function() {
       }
 
       function isNumericMultiname(mn) {
-        return mn instanceof Multiname && isNumeric(mn.name) ||
+        return mn instanceof Multiname && Multiname.isNumeric(mn) ||
                mn instanceof MultinameType && (mn.name instanceof TraitsType && mn.name.isNumeric());
       }
 

src/avm2/parser.ts

@@ -1287,10 +1287,11 @@ module Shumway.AVM2.ABC {
       } else if (typeof mn === "string") {
         return isNumeric(mn);
       }
+
       return !isNaN(parseInt(Multiname.getName(mn), 10));
     }
 
-    public static getName(mn): string {
+    public static getName(mn: Multiname): string {
       release || assert(mn instanceof Multiname);
       release || assert(!mn.isRuntimeName());
       return mn.getName();

src/avm2/runtime.ts

@@ -1468,7 +1468,6 @@ module Shumway.AVM2.Runtime {
     var mi = methodInfo;
     var cached = searchCodeCache(mi);
     if (!cached) {
-      warn("Compiling: " + compilationCount++ + ": " + methodInfo + " " + methodInfo.isInstanceInitializer + " " + methodInfo.isClassInitializer);
       var result = Compiler.compileMethod(mi, scope, hasDynamicScope);
       var parameters = result.parameters;
       var body = result.body;

src/avm2/tests/regress/correctness/pass/class-scope.as

@@ -0,0 +1,55 @@
+package {
+  public class A {
+    static var a = 1;
+  }
+
+  public class B extends A {
+    static var b = 2;
+  }
+
+  public class C extends B {
+    static var c = 3;
+    static function foo() {
+      trace(a + b + c);
+      new Array(Number(10));
+    }
+    function bar() {
+      var d = 4;
+      trace(a + b + c);
+      foo();
+      (function () {
+        var c0 = 0;
+        (function () {
+          var c1 = 1;
+          (function () {
+            var c2 = 2;
+            (function () {
+              var c3 = 3;
+              (function () {
+                var c4 = 4;
+                (function () {
+                  var c5 = 5;
+                  (function () {
+                    var c6 = 6;
+                    (function () {
+                      var c7 = 7;
+                      (function () {
+                        var c8 = 8;
+                        (function () {
+                          var c9 = 9;
+                          (function () {
+                            trace(c0 + c1 + c2 + c3 + c4 + c5 + c6 + c7 + c8 + c9);
+                          })();
+                        })();
+                      })();
+                    })();
+                  })();
+                })();
+              })();
+            })();
+          })();
+        })();
+      })();
+    }
+  }
+}

src/avm2/tests/regress/correctness/pass/classes-4.as

@@ -0,0 +1,15 @@
+package {
+  public class A {
+    public static var x = 32;
+    public native function get foo() : Boolean;
+  }
+
+  public class B extends A {
+    public function get foo() : Boolean {
+      trace ("B::foo()");
+    }
+  }
+
+  (new A()).foo;
+  (new B()).foo;
+}

src/avm2/tests/regress/correctness/pass/names-index.as

@@ -0,0 +1,49 @@
+package {
+  function foo(o: Array) {
+    trace("--- Weird Property Names ---");
+    o[12356712387125673512] = "Hello";
+    o[-0] = "Minus Zero";
+    o[1/0] = "INFINITY AND BEYOND";
+    o[-1/0] = "NEG INFINITY AND BELOW";
+    o["00"] = "DOUBLE ZERO";
+    o[NaN] = "NANANANANA";
+    o[123.456] = "FLOAT";
+    o[123.456e+123] = "HUGE";
+    o[123.456789e+123] = "HUGE 2";
+    o[123] = "123";
+    o["123"] = "XYZ";
+    o["12356712387125673512"] = "XYZ";
+    o["12356712387125673512"] += " Hello";
+    o["-0"] += " Minus Zero";
+    o["00"] += " DOUBLE ZERO";
+    o["NaN"] += " NANANANANA";
+    o["123.456"] += " FLOAT";
+    o["123.456e+123"] += " HUGE";
+    o["123.456789e+123"] += " HUGE 2";
+    o[" "] = "SPACE";
+
+    trace(o[12356712387125673512]);
+    trace(o["12356712387125673512"]);
+    trace(o[0]);
+    trace(o[Infinity]);
+    trace(o[-Infinity]);
+    trace(o["00"]);
+    trace(o[NaN]);
+    trace(o[123.456]);
+    trace(o[123.456e+123]);
+    trace(o[123.456789e+123]);
+    trace(o[123.456789e+123567]);
+    trace(o[" "]);
+    trace("for");
+    var s = 0;
+    for (var k in o) {
+      s += String(k).length;
+    }
+    trace(s);
+  }
+
+  (function () {
+    foo([]);
+    trace("--- Done ---");
+  })();
+}

src/avm2/tests/regress/correctness/pass/props-7.as

@@ -0,0 +1,6 @@
+package {
+  (function (o) {
+    trace("--- XML ---");
+    trace(o.@x);
+  })(<a x="HELLO">test</a>);
+}

src/avm2/utilities.ts

@@ -76,7 +76,9 @@ module Shumway {
     return +x;
   }
 
-  export function isNumberString(value: string): boolean {
+  export function isNumericString(value: string): boolean {
+    // ECMAScript 5.1 - 9.8.1 Note 1, this expression is true for all
+    // numbers x other than -0.
     return String(Number(value)) === value;
   }
 
@@ -87,7 +89,7 @@ module Shumway {
     if (typeof value === "number") {
       return true;
     } else if (typeof value === "string") {
-      return isIndex(value) || isNumberString(value);
+      return isIndex(value) || isNumericString(value);
     } else {
       Debug.notImplemented(typeof value);
     }