Mercurial > jdk8-mips64-public > nashorn / changeset

     1.1 --- a/.hgignore	Thu May 30 10:58:35 2013 -0700
     1.2 +++ b/.hgignore	Mon Jun 03 23:24:36 2013 -0700
     1.3 @@ -24,3 +24,4 @@
     1.4  .idea/*
     1.5  test/lib/testng.jar
     1.6  test/script/external/*
     1.7 +.project

     2.1 --- a/docs/JavaScriptingProgrammersGuide.html	Thu May 30 10:58:35 2013 -0700
     2.2 +++ b/docs/JavaScriptingProgrammersGuide.html	Mon Jun 03 23:24:36 2013 -0700
     2.3 @@ -71,9 +71,20 @@
     2.4  Arrays</a></span></li>
     2.5  <li><span><a href="#jsimplement">Implementing Java
     2.6  Interfaces</a></span></li>
     2.7 -<li><span><a href="#jsextend">Extending Java classes
     2.8 +<li><span><a href="#jsextendabstract">Extending Abstract Java Classes
     2.9 +</a></span></li>
    2.10 +<li><span><a href="#jsextendconcrete">Extending Concrete Java Classes
    2.11 +</a></span></li>
    2.12 +<li><span><a href="#jsimplementmultiple">Implementing Multiple Java Interfaces
    2.13 +</a></span></li>
    2.14 +<li><span><a href="#classBoundImplementations">Class-Bound Implementations
    2.15  </a></span></li>
    2.16  <li><span><a href="#jsoverload">Overload Resolution</a></span></li>
    2.17 +<li><span><a href="#dataTypeMapping">Mapping of Data Types Between Java
    2.18 +and JavaScript</a></span></li>
    2.19 +
    2.20 +
    2.21 +
    2.22  </ul>
    2.23  </li>
    2.24  <li><span><a href="#engineimpl">Implementing Your Own Script
    2.25 @@ -466,10 +477,10 @@
    2.26  </code>
    2.27  </pre> 
    2.28  
    2.29 -Note that the name of the type is always a string for a fully qualified name. You can use any of these types to create new instances, e.g.:
    2.30 +Note that the name of the type is always a string for a fully qualified name. You can use any of these expressions to create new instances, e.g.:
    2.31  
    2.32  <pre><code>
    2.33 - var anArrayList = new Java.type("java.util.ArrayList")
    2.34 + var anArrayList = new (Java.type("java.util.ArrayList"))
    2.35  </code></pre> 
    2.36  
    2.37  or
    2.38 @@ -496,6 +507,37 @@
    2.39  <p>
    2.40  You can access both static and non-static inner classes. If you want to create an instance of a non-static inner class, remember to pass an instance of its outer class as the first argument to the constructor.
    2.41  </p>
    2.42 +<p>
    2.43 +In addition to creating new instances, the type objects returned from <code>Java.type</code> calls can also be used to access the
    2.44 +static fields and methods of the classes:
    2.45 +<pre><code>
    2.46 + var File = Java.type("java.io.File")
    2.47 + File.createTempFile("nashorn", ".tmp")
    2.48 +</code></pre> 
    2.49 +<p>
    2.50 +Methods with names of the form <code>isXxx()</code>, <code>getXxx()</code>, and <code>setXxx()</code> can also be used as properties, for both instances and statics.
    2.51 +</p>
    2.52 +<p>
    2.53 +A type object returned from <code>Java.type</code> is distinct from a <code>java.lang.Class</code> object. You can obtain one from the other using properties <code>class</code> and <code>static</code> on them.
    2.54 +<pre><code>
    2.55 + var ArrayList = Java.type("java.util.ArrayList")
    2.56 + var a = new ArrayList
    2.57 +
    2.58 + // All of the following print true:
    2.59 + print("Type acts as target of instanceof: " + (a instanceof ArrayList))
    2.60 + print("Class doesn't act as target of instanceof: " + !(a instanceof a.getClass()))
    2.61 + print("Type is not same as instance's getClass(): " + (a.getClass() !== ArrayList))
    2.62 + print("Type's `class` property is same as instance getClass(): " + (a.getClass() === ArrayList.class))
    2.63 + print("Type is same as instance getClass()'s `static` property: " + (a.getClass().static === ArrayList))
    2.64 +</code></pre> 
    2.65 +<p>
    2.66 +You can think of the type object as similar to the class names as used in Java source code: you use them as the
    2.67 +arguments to the <code>new</code> and <code>instanceof</code> operators and as the namespace for the static fields
    2.68 +and methods, but they are different than the runtime <code>Class</code> objects returned by <code>getClass()</code> calls.
    2.69 +Syntactically and semantically, this separation produces code that is most similar to Java code, where a distinction
    2.70 +between compile-time class expressions and runtime class objects also exists. (Also, Java can't have the equivalent of <code>static</code>
    2.71 +property on a <code>Class</code> object since compile-time class expressions are never reified as objects).
    2.72 +</p>
    2.73  <hr>
    2.74  <a name="jsimport" id="jsimport"></a>
    2.75  <h3>Importing Java Packages, Classes</h3>
    2.76 @@ -558,10 +600,7 @@
    2.77  <a name="jsarrays" id="jsarrays"></a>
    2.78  <h3>Creating, Converting and Using Java Arrays</h3>
    2.79  <p>
    2.80 -Array element access or length access is
    2.81 -the same as in Java. Also, a script array can be used when a Java
    2.82 -method expects a Java array (auto conversion). So in most cases we
    2.83 -don't have to create Java arrays explicitly.</p>
    2.84 +Array element access or length access is the same as in Java.</p>
    2.85  <pre><code>
    2.86  // <a href="source/javaarray.js">javaarray.js</a>
    2.87  
    2.88 @@ -577,27 +616,31 @@
    2.89  </pre>
    2.90  <p>
    2.91  It is also possible to convert between JavaScript and Java arrays.
    2.92 -Given a JavaScript array and a Java type, <code>Java.toJavaArray</code> returns a Java array with the same initial contents, and with the specified component type. 
    2.93 +Given a JavaScript array and a Java type, <code>Java.to</code> returns a Java array with the same initial contents, and with the specified array type. 
    2.94  </p>
    2.95  <pre><code>
    2.96   var anArray = [1, "13", false]
    2.97 - var javaIntArray = Java.toJavaArray(anArray, "int")
    2.98 + var javaIntArray = Java.to(anArray, "int[]")
    2.99   print(javaIntArray[0]) // prints 1
   2.100   print(javaIntArray[1]) // prints 13, as string "13" was converted to number 13 as per ECMAScript ToNumber conversion
   2.101   print(javaIntArray[2]) // prints 0, as boolean false was converted to number 0 as per ECMAScript ToNumber conversion
   2.102  </code></pre>
   2.103  <p>
   2.104 -Given a Java array or Collection, <code>Java.toJavaScriptArray</code> returns a JavaScript array with a shallow copy of its contents. Note that in most cases, you can use Java arrays and lists natively in Nashorn; in cases where for some reason you need to have an actual JavaScript native array (e.g. to work with the array comprehensions functions), you will want to use this method.i
   2.105 +You can use either a string or a type object returned from <code>Java.type()</code> to specify the type of the array. 
   2.106 +You can also omit the array type, in which case a <code>Object[]</code> will be created.
   2.107 +</p>
   2.108 +<p>
   2.109 +Given a Java array or Collection, <code>Java.from</code> returns a JavaScript array with a shallow copy of its contents. Note that in most cases, you can use Java arrays and lists natively in Nashorn; in cases where for some reason you need to have an actual JavaScript native array (e.g. to work with the array comprehensions functions), you will want to use this method.
   2.110  </p>
   2.111  <pre><code>
   2.112  var File = Java.type("java.io.File");
   2.113  var listCurDir = new File(".").listFiles();
   2.114 -var jsList = Java.toJavaScriptArray(listCurDir);
   2.115 +var jsList = Java.from(listCurDir);
   2.116  print(jsList);
   2.117  </code></pre>
   2.118  <hr>
   2.119  <a name="jsimplement" id="jsimplement"></a>
   2.120 -<h3>Implementing Java Interfaces</h3>
   2.121 +<h3>Implementing Java interfaces</h3>
   2.122  <p>A Java interface can be implemented in JavaScript by using a
   2.123  Java anonymous class-like syntax:</p>
   2.124  <pre><code>
   2.125 @@ -631,8 +674,8 @@
   2.126  </code>
   2.127  </pre>
   2.128  <hr>
   2.129 -<a name="jsextend" id="jsextend"></a>
   2.130 -<h3>Extending Java classes</h3>
   2.131 +<a name="jsextendabstract" id="jsextendabstract"></a>
   2.132 +<h3>Extending Abstract Java Classes</h3>
   2.133  <p>
   2.134  If a Java class is abstract, you can instantiate an anonymous subclass of it using an argument list that is applicable to any of its public or protected constructors, but inserting a JavaScript object with functions properties that provide JavaScript implementations of the abstract methods. If method names are overloaded, the JavaScript function will provide implementation for all overloads. E.g.:
   2.135  </p>
   2.136 @@ -671,6 +714,9 @@
   2.137  
   2.138  Here, <code>Timer.schedule()</code> expects a <code>TimerTask</code> as its argument, so Nashorn creates an instance of a TimerTask subclass and uses the passed function to implement its only abstract method, run(). In this usage though, you can't use non-default constructors; the type must be either an interface, or must have a protected or public no-arg constructor.
   2.139  
   2.140 +<hr>
   2.141 +<a name="jsextendconcrete" id="jsextendconcrete"></a>
   2.142 +<h3>Extending Concrete Java Classes</h3>
   2.143  <p>
   2.144  To extend a concrete Java class, you have to use <code>Java.extend</code> function.
   2.145  <code>Java.extend</code> returns a type object for a subclass of the specified Java class (or implementation of the specified interface) that acts as a script-to-Java adapter for it.  
   2.146 @@ -695,26 +741,178 @@
   2.147  printSizeInvokedArrayList.size();
   2.148  printAddInvokedArrayList.add(33, 33);
   2.149  </code></pre>
   2.150 +<p>
   2.151 +The reason you must use <code>Java.extend()</code> with concrete classes is that with concrete classes, there can be a 
   2.152 +syntactic ambiguity if you just invoke their constructor. Consider this example:
   2.153 +</p>
   2.154 +<pre><code>
   2.155 +var t = new java.lang.Thread({ run: function() { print("Hello!") } })
   2.156 +</code></pre>
   2.157 +<p>
   2.158 +If we allowed subclassing of concrete classes with constructor syntax, Nashorn couldn't tell if you're creating a new 
   2.159 +<code>Thread</code> and passing it a <code>Runnable</code> at this point, or you are subclassing <code>Thread</code> and
   2.160 +passing it a new implementation for its own <code>run()</code> method.
   2.161 +</p>
   2.162 +<hr>
   2.163 +<a name="jsimplementmultiple" id="jsimplementmultiple"></a>
   2.164 +<h3>Implementing Multiple Interfaces</h3>
   2.165 +<p>
   2.166 +<code>Java.extend</code> can in fact take a list of multiple types. At most one of the types can be a class, and the rest must
   2.167 +be interfaces (the class doesn't have to be the first in the list). You will get back an object that extends the class and 
   2.168 +implements all the interfaces. (Obviously, if you only specify interfaces and no class, the object will extend <code>java.lang.Object</code>).
   2.169 +<hr>
   2.170 +<a name="classBoundImplementations" id="classBoundImplementations"></a>
   2.171 +<h3>Class-Bound Implementations</h3>
   2.172 +<p>
   2.173 +The methods shown so far for extending Java classes and implementing interfaces &ndash; passing an implementation JavaScript object 
   2.174 +or function to a constructor, or using <code>Java.extend</code> with <code>new</code> &ndash; all produce classes that take an
   2.175 +extra JavaScript object parameter in their constructors that specifies the implementation. The implementation is therefore always bound
   2.176 +to the actual instance being created with <code>new</code>, and not to the whole class. This has some advantages, for example in the
   2.177 +memory footprint of the runtime, as Nashorn can just create a single "universal adapter" for every combination of types being implemented.
   2.178 +In reality, the below code shows that different instantiations of, say, <code>Runnable</code> have the same class regardless of them having
   2.179 +different JavaScript implementation objects:
   2.180 +</p>
   2.181 +<pre><code>
   2.182 +var Runnable = java.lang.Runnable;
   2.183 +var r1 = new Runnable(function() { print("I'm runnable 1!") })
   2.184 +var r2 = new Runnable(function() { print("I'm runnable 2!") })
   2.185 +r1.run()
   2.186 +r2.run()
   2.187 +print("We share the same class: " + (r1.class === r2.class))
   2.188 +</code></pre>
   2.189 +<p>
   2.190 +prints:
   2.191 +</p>
   2.192 +<pre><code>
   2.193 +I'm runnable 1!
   2.194 +I'm runnable 2!
   2.195 +We share the same class: true
   2.196 +</code></pre>
   2.197 +<p>
   2.198 +Sometimes, however, you'll want to extend a Java class or implement an interface with implementation bound to the class, not to
   2.199 +its instances. Such a need arises, for example, when you need to pass the class for instantiation to an external API; prime example
   2.200 +of this is the JavaFX framework where you need to pass an Application class to the FX API and let it instantiate it.
   2.201 +</p>
   2.202 +<p>
   2.203 +Fortunately, there's a solution for that: <code>Java.extend()</code> &ndash; aside from being able to take any number of type parameters
   2.204 +denoting a class to extend and interfaces to implement &ndash; can also take one last argument that has to be a JavaScript object
   2.205 +that serves as the implementation for the methods. In this case, <code>Java.extend()</code> will create a class that has the same
   2.206 +constructors as the original class had, as they don't need to take an an extra implementation object parameter. The example below
   2.207 +shows how you can create class-bound implementations, and shows that in this case, the implementation classes for different invocations
   2.208 +are indeed different:
   2.209 +</p>
   2.210 +<pre><code>
   2.211 +var RunnableImpl1 = Java.extend(java.lang.Runnable, function() { print("I'm runnable 1!") })
   2.212 +var RunnableImpl2 = Java.extend(java.lang.Runnable, function() { print("I'm runnable 2!") })
   2.213 +var r1 = new RunnableImpl1()
   2.214 +var r2 = new RunnableImpl2()
   2.215 +r1.run()
   2.216 +r2.run()
   2.217 +print("We share the same class: " + (r1.class === r2.class))
   2.218 +</code></pre>
   2.219 +<p>
   2.220 +prints:
   2.221 +</p>
   2.222 +<pre><code>
   2.223 +I'm runnable 1!
   2.224 +I'm runnable 2!
   2.225 +We share the same class: false
   2.226 +</code></pre>
   2.227 +<p>
   2.228 +As you can see, the major difference here is that we moved the implementation object into the invocation of <code>Java.extend</code>
   2.229 +from the constructor invocations &ndash; indeed the constructor invocations now don't even need to take an extra parameter! Since
   2.230 +the implementations are bound to a class, the two classes obviously can't be the same, and we indeed see that the two runnables no
   2.231 +longer share the same class &ndash; every invocation of <code>Java.extend()</code> with a class-specific implementation object triggers
   2.232 +the creation of a new Java adapter class.
   2.233 +</p>
   2.234 +<p>
   2.235 +Finally, the adapter classes with class-bound implementations can <i>still</i> take an additional constructor parameter to further
   2.236 +override the behavior on a per-instance basis. Thus, you can even combine the two approaches: you can provide part of the implementation
   2.237 +in a class-based JavaScript implementation object passed to <code>Java.extend</code>, and part in another object passed to the constructor.
   2.238 +Whatever functions are provided by the constructor-passed object will override the functions in the class-bound object.
   2.239 +</p>
   2.240 +<pre><code>
   2.241 +var RunnableImpl = Java.extend(java.lang.Runnable, function() { print("I'm runnable 1!") })
   2.242 +var r1 = new RunnableImpl()
   2.243 +var r2 = new RunnableImpl(function() { print("I'm runnable 2!") })
   2.244 +r1.run()
   2.245 +r2.run()
   2.246 +print("We share the same class: " + (r1.class === r2.class))
   2.247 +</code></pre>
   2.248 +<p>
   2.249 +prints:
   2.250 +</p>
   2.251 +<pre><code>
   2.252 +I'm runnable 1!
   2.253 +I'm runnable 2!
   2.254 +We share the same class: true
   2.255 +</code></pre>
   2.256  <hr>
   2.257  <a name="jsoverload" id="jsoverload"></a>
   2.258  <h3>Overload Resolution</h3>
   2.259  <p>Java methods can be overloaded by argument types. In Java,
   2.260  overload resolution occurs at compile time (performed by javac).
   2.261 -When calling Java methods from a script, the script
   2.262 -interpreter/compiler needs to select the appropriate method. With
   2.263 -the JavaScript engine, you do not need to do anything special - the
   2.264 -correct Java method overload variant is selected based on the
   2.265 -argument types. But, sometimes you may want (or have) to explicitly
   2.266 -select a particular overload variant.</p>
   2.267 +When calling Java methods from Nashorn, the appropriate method will be
   2.268 +selected based on the argument types at invocation time. You do not need
   2.269 +to do anything special &ndash; the correct Java method overload variant 
   2.270 +is selected based automatically. You still have the option of explicitly
   2.271 +specifying a particular overload variant. Reasons for this include 
   2.272 +either running into a genuine ambiguity with actual argument types, or 
   2.273 +rarely reasons of performance &ndash; if you specify the actual overload
   2.274 +then the engine doesn't have to perform resolution during invocation.
   2.275 +Individual overloads of a Java methods are exposed as special properties
   2.276 +with the name of the method followed with its signature in parentheses. 
   2.277 +You can invoke them like this:</p>
   2.278  <pre><code>
   2.279  // <a href="source/overload.js">overload.js</a>
   2.280  
   2.281  var out = java.lang.System.out;
   2.282  
   2.283  // select a particular print function 
   2.284 -out["println(java.lang.Object)"]("hello");
   2.285 +out["println(Object)"]("hello");
   2.286  </code>
   2.287  </pre>
   2.288 +<p>
   2.289 +Note that you normally don't even have to use qualified class names in 
   2.290 +the signatures as long as the unqualified name of the type is sufficient
   2.291 +for uniquely identifying the signature. In practice this means that only
   2.292 +in the extremely unlikely case that two overloads only differ in 
   2.293 +parameter types that have identical unqualified names but come from 
   2.294 +different packages would you need to use the fully qualified name of the
   2.295 +class.
   2.296 +</p>
   2.297 +<hr>
   2.298 +<a name="dataTypeMapping" id="dataTypeMapping"></a>
   2.299 +<h3>Mapping of Data Types Between Java and JavaScript</h3>
   2.300 +<p>
   2.301 +We have previously shown some of the data type mappings between Java and JavaScript.
   2.302 +We saw that arrays need to be explicitly converted. We have also shown that JavaScript functions
   2.303 +are automatically converted to SAM types when passed as parameters to Java methods. Most other
   2.304 +conversions work as you would expect.
   2.305 +</p>
   2.306 +<p>
   2.307 +Every JavaScript object is also a <code>java.util.Map</code> so APIs receiving maps will receive them directly.
   2.308 +</p>
   2.309 +<p>
   2.310 +When numbers are passed to a Java API, they will be converted to the expected target numeric type, either boxed or
   2.311 +primitive, but if the target type is less specific, say <code>Number</code> or <code>Object</code>, you can only
   2.312 +count on them being a <code>Number</code>, and have to test specifically for whether it's a boxed <code>Double</code>,
   2.313 +<code>Integer</code>, <code>Long</code>, etc. &ndash; it can be any of these due to internal optimizations. Also, you 
   2.314 +can pass any JavaScript value to a Java API expecting either a boxed or primitive number; the JavaScript specification's
   2.315 +<code>ToNumber</code> conversion algorithm will be applied to the value.
   2.316 +</p>
   2.317 +<p>
   2.318 +In a similar vein, if a Java method expects a <code>String</code> or a <code>Boolean</code>, the values will be
   2.319 +converted using all conversions allowed by the JavaScript specification's <code>ToString</code> and <code>ToBoolean</code>
   2.320 +conversions.
   2.321 +</p>
   2.322 +<p>
   2.323 +Finally, a word of caution about strings. Due to internal performance optimizations of string operations, JavaScript strings are
   2.324 +not always necessarily of type <code>java.lang.String</code>, but they will always be of type <code>java.lang.CharSequence</code>.
   2.325 +If you pass them to a Java method that expects a <code>java.lang.String</code> parameter, then you will naturally receive a Java
   2.326 +String, but if the signature of your method is more generic, i.e. it receives a <code>java.lang.Object</code> parameter, you can 
   2.327 +end up with an object of private engine implementation class that implements <code>CharSequence</code> but is not a Java String.
   2.328 +</p>
   2.329  <hr>
   2.330  <a name="engineimpl" id="engineimpl"></a>
   2.331  <h2>Implementing Your Own Script Engine</h2>

     3.1 --- a/docs/source/javaarray.js	Thu May 30 10:58:35 2013 -0700
     3.2 +++ b/docs/source/javaarray.js	Mon Jun 03 23:24:36 2013 -0700
     3.3 @@ -40,7 +40,7 @@
     3.4  
     3.5  // convert a script array to Java array
     3.6  var anArray = [1, "13", false];
     3.7 -var javaIntArray = Java.toJavaArray(anArray, "int");
     3.8 +var javaIntArray = Java.to(anArray, "int[]");
     3.9  print(javaIntArray[0]);// prints 1
    3.10  print(javaIntArray[1]); // prints 13, as string "13" was converted to number 13 as per ECMAScript ToNumber conversion
    3.11  print(javaIntArray[2]);// prints 0, as boolean false was converted to number 0 as per ECMAScript ToNumber conversion
    3.12 @@ -48,5 +48,5 @@
    3.13  // convert a Java array to a JavaScript array
    3.14  var File = Java.type("java.io.File");
    3.15  var listCurDir = new File(".").listFiles();
    3.16 -var jsList = Java.toJavaScriptArray(listCurDir);
    3.17 +var jsList = Java.from(listCurDir);
    3.18  print(jsList);

     4.1 --- a/make/build-benchmark.xml	Thu May 30 10:58:35 2013 -0700
     4.2 +++ b/make/build-benchmark.xml	Mon Jun 03 23:24:36 2013 -0700
     4.3 @@ -24,258 +24,270 @@
     4.4  <project name="nashorn-benchmarks" default="all" basedir="..">
     4.5  
     4.6    <target name="octane-init" depends="jar">
     4.7 -    <fileset id="octane-set"
     4.8 -	     dir="${octane-test-sys-prop.test.js.roots}"
     4.9 -	     excludes="${octane-test-sys-prop.test.js.exclude.list}">
    4.10 -      <include name="*.js"/>
    4.11 -    </fileset>
    4.12 -    <pathconvert pathsep=" " property="octane-tests" refid="octane-set"/>
    4.13 +    <property name="octane-tests" value="box2d code-load crypto deltablue earley-boyer gbemu navier-stokes pdfjs raytrace regexp richards splay"/>
    4.14 +  </target>
    4.15 +  
    4.16 +  <!-- ignore benchmarks where rhino crashes -->
    4.17 +  <target name="octane-init-rhino" depends="jar">
    4.18 +    <property name="octane-tests" value="box2d code-load crypto deltablue earley-boyer gbemu navier-stokes raytrace regexp richards splay"/>
    4.19    </target>
    4.20  
    4.21    <!-- box2d -->
    4.22    <target name="octane-box2d" depends="jar">
    4.23      <antcall target="run-octane">
    4.24 -      <param name="octane-tests" value="${octane-test-sys-prop.test.js.roots}/box2d.js"/>
    4.25 +      <param name="octane-tests" value="box2d"/>
    4.26      </antcall>
    4.27    </target>
    4.28  
    4.29    <target name="octane-box2d-v8" depends="jar">
    4.30      <antcall target="run-octane-v8">
    4.31 -      <param name="octane-tests" value="${octane-test-sys-prop.test.js.roots}/box2d.js"/>
    4.32 +      <param name="octane-tests" value="box2d"/>
    4.33      </antcall>
    4.34    </target>
    4.35  
    4.36    <target name="octane-box2d-rhino" depends="jar">
    4.37      <antcall target="run-octane-rhino">
    4.38 -      <param name="octane-tests" value="${octane-test-sys-prop.test.js.roots}/box2d.js"/>
    4.39 +      <param name="octane-tests" value="box2d"/>
    4.40      </antcall>
    4.41    </target>
    4.42  
    4.43 +
    4.44    <!-- code-load -->  
    4.45    <target name="octane-code-load" depends="jar">
    4.46      <antcall target="run-octane">
    4.47 -      <param name="octane-tests" value="${octane-test-sys-prop.test.js.roots}/code-load.js"/>
    4.48 +      <param name="octane-tests" value="code-load"/>
    4.49      </antcall>
    4.50    </target>
    4.51  
    4.52    <target name="octane-code-load-v8" depends="jar">
    4.53      <antcall target="run-octane-v8">
    4.54 -      <param name="octane-tests" value="${octane-test-sys-prop.test.js.roots}/code-load.js"/>
    4.55 +      <param name="octane-tests" value="code-load"/>
    4.56      </antcall>
    4.57    </target>
    4.58  
    4.59    <target name="octane-code-load-rhino" depends="jar">
    4.60      <antcall target="run-octane-rhino">
    4.61 -      <param name="octane-tests" value="${octane-test-sys-prop.test.js.roots}/code-load.js"/>
    4.62 +      <param name="octane-tests" value="code-load"/>
    4.63      </antcall>
    4.64    </target>
    4.65  
    4.66 +
    4.67    <!-- crypto -->
    4.68    <target name="octane-crypto" depends="jar">
    4.69      <antcall target="run-octane">
    4.70 -      <param name="octane-tests" value="${octane-test-sys-prop.test.js.roots}/crypto.js"/>
    4.71 +      <param name="octane-tests" value="crypto"/>
    4.72      </antcall>
    4.73    </target>
    4.74  
    4.75    <target name="octane-crypto-v8" depends="jar">
    4.76      <antcall target="run-octane-v8">
    4.77 -      <param name="octane-tests" value="${octane-test-sys-prop.test.js.roots}/crypto.js"/>
    4.78 +      <param name="octane-tests" value="crypto"/>
    4.79      </antcall>
    4.80    </target>
    4.81  
    4.82    <target name="octane-crypto-rhino" depends="jar">
    4.83      <antcall target="run-octane-rhino">
    4.84 -      <param name="octane-tests" value="${octane-test-sys-prop.test.js.roots}/crypto.js"/>
    4.85 +      <param name="octane-tests" value="crypto"/>
    4.86      </antcall>
    4.87    </target>
    4.88  
    4.89 +
    4.90    <!-- deltablue -->
    4.91    <target name="octane-deltablue" depends="jar">
    4.92      <antcall target="run-octane">
    4.93 -      <param name="octane-tests" value="${octane-test-sys-prop.test.js.roots}/deltablue.js"/>
    4.94 +      <param name="octane-tests" value="deltablue"/>
    4.95      </antcall>
    4.96    </target>
    4.97  
    4.98    <target name="octane-deltablue-v8" depends="jar">
    4.99      <antcall target="run-octane-v8">
   4.100 -      <param name="octane-tests" value="${octane-test-sys-prop.test.js.roots}/deltablue.js"/>
   4.101 +      <param name="octane-tests" value="deltablue"/>
   4.102      </antcall>
   4.103    </target>
   4.104  
   4.105    <target name="octane-deltablue-rhino" depends="jar">
   4.106      <antcall target="run-octane-rhino">
   4.107 -      <param name="octane-tests" value="${octane-test-sys-prop.test.js.roots}/deltablue.js"/>
   4.108 +      <param name="octane-tests" value="deltablue"/>
   4.109      </antcall>
   4.110    </target>
   4.111  
   4.112 +
   4.113    <!-- earley-boyer -->
   4.114    <target name="octane-earley-boyer" depends="jar">
   4.115      <antcall target="run-octane">
   4.116 -      <param name="octane-tests" value="${octane-test-sys-prop.test.js.roots}/earley-boyer.js"/>
   4.117 +      <param name="octane-tests" value="earley-boyer"/>
   4.118      </antcall>
   4.119    </target>
   4.120  
   4.121    <target name="octane-earley-boyer-v8" depends="jar">
   4.122      <antcall target="run-octane-v8">
   4.123 -      <param name="octane-tests" value="${octane-test-sys-prop.test.js.roots}/earley-boyer.js"/>
   4.124 +      <param name="octane-tests" value="earley-boyer"/>
   4.125      </antcall>
   4.126    </target>
   4.127  
   4.128    <target name="octane-earley-boyer-rhino" depends="jar">
   4.129      <antcall target="run-octane-rhino">
   4.130 -      <param name="octane-tests" value="${octane-test-sys-prop.test.js.roots}/earley-boyer.js"/>
   4.131 +      <param name="octane-tests" value="earley-boyer"/>
   4.132      </antcall>
   4.133    </target>
   4.134  
   4.135 +
   4.136    <!-- gbemu -->  
   4.137    <target name="octane-gbemu" depends="jar">
   4.138      <antcall target="run-octane">
   4.139 -      <param name="octane-tests" value="${octane-test-sys-prop.test.js.roots}/gbemu.js"/>
   4.140 +      <param name="octane-tests" value="gbemu"/>
   4.141      </antcall>
   4.142    </target>
   4.143  
   4.144    <target name="octane-gbemu-v8" depends="jar">
   4.145      <antcall target="run-octane-v8">
   4.146 -      <param name="octane-tests" value="${octane-test-sys-prop.test.js.roots}/gbemu.js"/>
   4.147 +      <param name="octane-tests" value="gbemu"/>
   4.148      </antcall>
   4.149    </target>
   4.150  
   4.151    <target name="octane-gbemu-rhino" depends="jar">
   4.152      <antcall target="run-octane-rhino">
   4.153 -      <param name="octane-tests" value="${octane-test-sys-prop.test.js.roots}/gbemu.js"/>
   4.154 +      <param name="octane-tests" value="gbemu"/>
   4.155      </antcall>
   4.156    </target>
   4.157  
   4.158 +
   4.159    <!-- mandreel -->  
   4.160    <target name="octane-mandreel" depends="jar">
   4.161      <antcall target="run-octane">
   4.162 -      <param name="octane-tests" value="${octane-test-sys-prop.test.js.roots}/mandreel.js"/>
   4.163 +      <param name="octane-tests" value="mandreel"/>
   4.164      </antcall>
   4.165    </target>
   4.166  
   4.167    <target name="octane-mandreel-v8" depends="jar">
   4.168      <antcall target="run-octane-v8">
   4.169 -      <param name="octane-tests" value="${octane-test-sys-prop.test.js.roots}/mandreel.js"/>
   4.170 +      <param name="octane-tests" value="mandreel"/>
   4.171      </antcall>
   4.172    </target>
   4.173  
   4.174    <target name="octane-mandreel-rhino" depends="jar">
   4.175      <antcall target="run-octane-rhino">
   4.176 -      <param name="octane-tests" value="${octane-test-sys-prop.test.js.roots}/mandreel.js"/>
   4.177 +      <param name="octane-tests" value="mandreel"/>
   4.178      </antcall>
   4.179    </target>
   4.180  
   4.181 +
   4.182    <!-- navier-stokes -->
   4.183    <target name="octane-navier-stokes" depends="jar">
   4.184      <antcall target="run-octane">
   4.185 -      <param name="octane-tests" value="${octane-test-sys-prop.test.js.roots}/navier-stokes.js"/>
   4.186 +      <param name="octane-tests" value="navier-stokes"/>
   4.187      </antcall>
   4.188    </target>
   4.189  
   4.190    <target name="octane-navier-stokes-v8" depends="jar">
   4.191      <antcall target="run-octane-v8">
   4.192 -      <param name="octane-tests" value="${octane-test-sys-prop.test.js.roots}/navier-stokes.js"/>
   4.193 +      <param name="octane-tests" value="navier-stokes"/>
   4.194      </antcall>
   4.195    </target>
   4.196  
   4.197    <target name="octane-navier-stokes-rhino" depends="jar">
   4.198      <antcall target="run-octane-rhino">
   4.199 -      <param name="octane-tests" value="${octane-test-sys-prop.test.js.roots}/navier-stokes.js"/>
   4.200 +      <param name="octane-tests" value="navier-stokes"/>
   4.201      </antcall>
   4.202    </target>
   4.203  
   4.204 +
   4.205    <!-- pdfjs -->  
   4.206    <target name="octane-pdfjs" depends="jar">
   4.207      <antcall target="run-octane">
   4.208 -      <param name="octane-tests" value="${octane-test-sys-prop.test.js.roots}/pdfjs.js"/>
   4.209 +      <param name="octane-tests" value="pdfjs"/>
   4.210      </antcall>
   4.211    </target>
   4.212  
   4.213    <target name="octane-pdfjs-v8" depends="jar">
   4.214      <antcall target="run-octane-v8">
   4.215 -      <param name="octane-tests" value="${octane-test-sys-prop.test.js.roots}/pdfjs.js"/>
   4.216 +      <param name="octane-tests" value="pdfjs"/>
   4.217      </antcall>
   4.218    </target>
   4.219  
   4.220    <target name="octane-pdfjs-rhino" depends="jar">
   4.221      <antcall target="run-octane-rhino">
   4.222 -      <param name="octane-tests" value="${octane-test-sys-prop.test.js.roots}/pdfjs.js"/>
   4.223 +      <param name="octane-tests" value="pdfjs"/>
   4.224      </antcall>
   4.225    </target>
   4.226  
   4.227 +
   4.228    <!-- raytrace -->
   4.229    <target name="octane-raytrace" depends="jar">
   4.230      <antcall target="run-octane">
   4.231 -      <param name="octane-tests" value="${octane-test-sys-prop.test.js.roots}/raytrace.js"/>
   4.232 +      <param name="octane-tests" value="raytrace"/>
   4.233      </antcall>
   4.234    </target>
   4.235  
   4.236    <target name="octane-raytrace-v8" depends="jar">
   4.237      <antcall target="run-octane-v8">
   4.238 -      <param name="octane-tests" value="${octane-test-sys-prop.test.js.roots}/raytrace.js"/>
   4.239 +      <param name="octane-tests" value="raytrace"/>
   4.240      </antcall>
   4.241    </target>
   4.242  
   4.243    <target name="octane-raytrace-rhino" depends="jar">
   4.244      <antcall target="run-octane-rhino">
   4.245 -      <param name="octane-tests" value="${octane-test-sys-prop.test.js.roots}/raytrace.js"/>
   4.246 +      <param name="octane-tests" value="raytrace"/>
   4.247      </antcall>
   4.248    </target>
   4.249  
   4.250 +
   4.251    <!-- regexp -->
   4.252    <target name="octane-regexp" depends="jar">
   4.253      <antcall target="run-octane">
   4.254 -      <param name="octane-tests" value="${octane-test-sys-prop.test.js.roots}/regexp.js"/>
   4.255 +      <param name="octane-tests" value="regexp"/>
   4.256      </antcall>
   4.257    </target>
   4.258  
   4.259    <target name="octane-regexp-octane-v8" depends="jar">
   4.260      <antcall target="run-octane-v8">
   4.261 -      <param name="octane-tests" value="${octane-test-sys-prop.test.js.roots}/regexp.js"/>
   4.262 +      <param name="octane-tests" value="regexp"/>
   4.263      </antcall>
   4.264    </target>
   4.265  
   4.266    <target name="octane-regexp-rhino" depends="jar">
   4.267      <antcall target="run-octane-rhino">
   4.268 -      <param name="octane-tests" value="${octane-test-sys-prop.test.js.roots}/regexp.js"/>
   4.269 +      <param name="octane-tests" value="regexp"/>
   4.270      </antcall>
   4.271    </target>
   4.272  
   4.273 +
   4.274    <!-- richards -->
   4.275    <target name="octane-richards" depends="jar">
   4.276      <antcall target="run-octane">
   4.277 -      <param name="octane-tests" value="${octane-test-sys-prop.test.js.roots}/richards.js"/>
   4.278 +      <param name="octane-tests" value="richards"/>
   4.279      </antcall>
   4.280    </target>
   4.281  
   4.282    <target name="octane-richards-v8" depends="jar">
   4.283      <antcall target="run-octane-v8">
   4.284 -      <param name="octane-tests" value="${octane-test-sys-prop.test.js.roots}/richards.js"/>
   4.285 +      <param name="octane-tests" value="richards"/>
   4.286      </antcall>
   4.287    </target>
   4.288  
   4.289    <target name="octane-richards-rhino" depends="jar">
   4.290      <antcall target="run-octane-rhino">
   4.291 -      <param name="octane-tests" value="${octane-test-sys-prop.test.js.roots}/richards.js"/>
   4.292 +      <param name="octane-tests" value="richards"/>
   4.293      </antcall>
   4.294    </target>
   4.295  
   4.296 +
   4.297    <!-- splay -->
   4.298    <target name="octane-splay" depends="jar">
   4.299      <antcall target="run-octane">
   4.300 -      <param name="octane-tests" value="${octane-test-sys-prop.test.js.roots}/splay.js"/>
   4.301 +      <param name="octane-tests" value="splay"/>
   4.302      </antcall>
   4.303    </target>
   4.304  
   4.305    <target name="octane-splay-v8" depends="jar">
   4.306      <antcall target="run-octane-v8">
   4.307 -      <param name="octane-tests" value="${octane-test-sys-prop.test.js.roots}/splay.js"/>
   4.308 +      <param name="octane-tests" value="splay"/>
   4.309      </antcall>
   4.310    </target>
   4.311  
   4.312    <target name="octane-splay-rhino" depends="jar">
   4.313      <antcall target="run-octane-rhino">
   4.314 -      <param name="octane-tests" value="${octane-test-sys-prop.test.js.roots}/splay.js"/>
   4.315 +      <param name="octane-tests" value="splay"/>
   4.316      </antcall>
   4.317    </target>
   4.318  
   4.319 @@ -307,7 +319,7 @@
   4.320    </target>
   4.321  
   4.322    <!-- run octane benchmarks using Rhino as runtime -->
   4.323 -  <target name="octane-rhino" depends="octane-init">
   4.324 +  <target name="octane-rhino" depends="octane-init-rhino">
   4.325      <antcall target="run-octane-rhino"/>
   4.326    </target>
   4.327    

     5.1 --- a/make/build.xml	Thu May 30 10:58:35 2013 -0700
     5.2 +++ b/make/build.xml	Mon Jun 03 23:24:36 2013 -0700
     5.3 @@ -212,7 +212,9 @@
     5.4             target="${javac.target}"
     5.5             debug="${javac.debug}"
     5.6             encoding="${javac.encoding}"
     5.7 -           includeantruntime="false"/>
     5.8 +           includeantruntime="false">
     5.9 +        <compilerarg line="-extdirs &quot;&quot;"/>
    5.10 +    </javac>
    5.11  
    5.12      <!-- tests that check nashorn internals and internal API -->
    5.13      <jar jarfile="${nashorn.internal.tests.jar}">
    5.14 @@ -305,6 +307,8 @@
    5.15        <include name="**/codegen/*Test.class"/>
    5.16        <include name="**/parser/*Test.class"/>
    5.17        <include name="**/runtime/*Test.class"/>
    5.18 +      <include name="**/runtime/regexp/*Test.class"/>
    5.19 +      <include name="**/runtime/regexp/joni/*Test.class"/>
    5.20        <include name="**/framework/*Test.class"/>
    5.21      </fileset>
    5.22  

     6.1 --- a/make/code_coverage.xml	Thu May 30 10:58:35 2013 -0700
     6.2 +++ b/make/code_coverage.xml	Mon Jun 03 23:24:36 2013 -0700
     6.3 @@ -139,6 +139,32 @@
     6.4        <arg value="${cc.merged.xml}"/>
     6.5        <arg value="-exclude"/>
     6.6        <arg value="com\.oracle\.nashorn\.runtime\.ScriptRuntime*"/>
     6.7 +      <arg value="-exclude"/>
     6.8 +      <arg value="jdk\.nashorn\.internal\.javaadapters*"/>
     6.9 +      <arg value="-exclude"/>
    6.10 +      <arg value="jdk\.nashorn\.internal\.objects\.annotations*"/>
    6.11 +      <arg value="-exclude"/>
    6.12 +      <arg value="jdk\.nashorn\.internal\.scripts*"/>
    6.13 +      <arg value="-exclude"/>
    6.14 +      <arg value="jdk\.nashorn\.internal\.lookup\.MethodHandleFactory*"/>
    6.15 +      <arg value="-exclude"/>
    6.16 +      <arg value="jdk\.nashorn\.internal\.test\.framework*"/>
    6.17 +      <arg value="-exclude"/>
    6.18 +      <arg value="jdk\.nashorn\.test\.models*"/>
    6.19 +      <arg value="-exclude"/>
    6.20 +      <arg value="jdk\.nashorn\.internal\.ir\.debug*"/>
    6.21 +      <arg value="-exclude"/>
    6.22 +      <arg value="jdk\.nashorn\.internal\.runtime\.regexp\.joni\.bench*"/>
    6.23 +      <arg value="-exclude"/>
    6.24 +      <arg value="jdk\.nashorn\.internal\.runtime\.DebugLogger*"/>
    6.25 +      <arg value="-exclude"/>
    6.26 +      <arg value="jdk\.nashorn\.internal\.runtime\.Timing*"/>
    6.27 +      <arg value="-exclude"/>
    6.28 +      <arg value="jdk\.nashorn\.internal\.runtime\.Logging*"/>
    6.29 +      <arg value="-exclude"/>
    6.30 +      <arg value="jdk\.nashorn\.internal\.runtime\.Debug*"/>
    6.31 +      <arg value="-exclude"/>
    6.32 +      <arg value="jdk\.nashorn\.internal\.objects\.NativeDebug*"/>
    6.33        <arg line="${cc.all.xmls}"/>
    6.34        <classpath>
    6.35          <pathelement location="${jcov.jar}"/>

     7.1 --- a/make/project.properties	Thu May 30 10:58:35 2013 -0700
     7.2 +++ b/make/project.properties	Mon Jun 03 23:24:36 2013 -0700
     7.3 @@ -87,6 +87,7 @@
     7.4  
     7.5  testng.listeners=\
     7.6   org.testng.reporters.SuiteHTMLReporter, \
     7.7 + org.testng.reporters.TestHTMLReporter, \
     7.8   org.testng.reporters.jq.Main, \
     7.9   org.testng.reporters.FailedReporter, \
    7.10   org.testng.reporters.XMLReporter \
    7.11 @@ -214,9 +215,13 @@
    7.12  run.test.xmx=3G
    7.13  run.test.xms=2G
    7.14  
    7.15 +run.test.user.language=tr
    7.16 +run.test.user.country=TR
    7.17 +
    7.18  #  -XX:+PrintCompilation -XX:+UnlockDiagnosticVMOptions -XX:+PrintNMethods
    7.19  # add '-Dtest.js.outofprocess' to run each test in a new sub-process
    7.20 -run.test.jvmargs.main=-server -Xmx${run.test.xmx} -XX:+TieredCompilation -ea -Dnashorn.debug=true -Dfile.encoding=UTF-8
    7.21 +run.test.jvmargs.main=-server -Xmx${run.test.xmx} -XX:+TieredCompilation -ea -Dfile.encoding=UTF-8 -Duser.language=${run.test.user.language} -Duser.country=${run.test.user.country}
    7.22 +
    7.23  #-XX:+HeapDumpOnOutOfMemoryError -XX:-UseCompressedKlassPointers -XX:+PrintHeapAtGC -XX:ClassMetaspaceSize=300M  
    7.24  run.test.jvmargs.octane.main=-Xms${run.test.xms} ${run.test.jvmargs.main}
    7.25  

     8.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     8.2 +++ b/src/jdk/nashorn/api/scripting/JSObject.java	Mon Jun 03 23:24:36 2013 -0700
     8.3 @@ -0,0 +1,87 @@
     8.4 +/*
     8.5 + * Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.
     8.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
     8.7 + *
     8.8 + * This code is free software; you can redistribute it and/or modify it
     8.9 + * under the terms of the GNU General Public License version 2 only, as
    8.10 + * published by the Free Software Foundation.  Oracle designates this
    8.11 + * particular file as subject to the "Classpath" exception as provided
    8.12 + * by Oracle in the LICENSE file that accompanied this code.
    8.13 + *
    8.14 + * This code is distributed in the hope that it will be useful, but WITHOUT
    8.15 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
    8.16 + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
    8.17 + * version 2 for more details (a copy is included in the LICENSE file that
    8.18 + * accompanied this code).
    8.19 + *
    8.20 + * You should have received a copy of the GNU General Public License version
    8.21 + * 2 along with this work; if not, write to the Free Software Foundation,
    8.22 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
    8.23 + *
    8.24 + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
    8.25 + * or visit www.oracle.com if you need additional information or have any
    8.26 + * questions.
    8.27 + */
    8.28 +
    8.29 +package jdk.nashorn.api.scripting;
    8.30 +
    8.31 +/**
    8.32 + * netscape.javascript.JSObject-like interface for nashorn script objects.
    8.33 + */
    8.34 +public abstract class JSObject {
    8.35 +    /**
    8.36 +     * Call a JavaScript method
    8.37 +     *
    8.38 +     * @param methodName name of method
    8.39 +     * @param args arguments to method
    8.40 +     * @return result of call
    8.41 +     */
    8.42 +    public abstract Object call(String methodName, Object args[]);
    8.43 +
    8.44 +    /**
    8.45 +     * Evaluate a JavaScript expression
    8.46 +     *
    8.47 +     * @param s JavaScript expression to evaluate
    8.48 +     * @return evaluation result
    8.49 +     */
    8.50 +    public abstract Object eval(String s);
    8.51 +
    8.52 +    /**
    8.53 +     * Retrieves a named member of a JavaScript object.
    8.54 +     *
    8.55 +     * @param name of member
    8.56 +     * @return member
    8.57 +     */
    8.58 +    public abstract Object getMember(String name);
    8.59 +
    8.60 +    /**
    8.61 +     * Retrieves an indexed member of a JavaScript object.
    8.62 +     *
    8.63 +     * @param index index of member slot
    8.64 +     * @return member
    8.65 +     */
    8.66 +    public abstract Object getSlot(int index);
    8.67 +
    8.68 +    /**
    8.69 +     * Remove a named member from a JavaScript object
    8.70 +     *
    8.71 +     * @param name name of member
    8.72 +     */
    8.73 +    public abstract void removeMember(String name);
    8.74 +
    8.75 +    /**
    8.76 +     * Set a named member in a JavaScript object
    8.77 +     *
    8.78 +     * @param name  name of member
    8.79 +     * @param value value of member
    8.80 +     */
    8.81 +    public abstract void setMember(String name, Object value);
    8.82 +
    8.83 +    /**
    8.84 +     * Set an indexed member in a JavaScript object
    8.85 +     *
    8.86 +     * @param index index of member slot
    8.87 +     * @param value value of member
    8.88 +     */
    8.89 +    public abstract void setSlot(int index, Object value);
    8.90 +}

     9.1 --- a/src/jdk/nashorn/api/scripting/ScriptObjectMirror.java	Thu May 30 10:58:35 2013 -0700
     9.2 +++ b/src/jdk/nashorn/api/scripting/ScriptObjectMirror.java	Mon Jun 03 23:24:36 2013 -0700
     9.3 @@ -42,7 +42,6 @@
     9.4  import jdk.nashorn.internal.runtime.ScriptFunction;
     9.5  import jdk.nashorn.internal.runtime.ScriptObject;
     9.6  import jdk.nashorn.internal.runtime.ScriptRuntime;
     9.7 -import netscape.javascript.JSObject;
     9.8  
     9.9  /**
    9.10   * Mirror object that wraps a given ScriptObject instance. User can

    10.1 --- a/src/jdk/nashorn/api/scripting/resources/engine.js	Thu May 30 10:58:35 2013 -0700
    10.2 +++ b/src/jdk/nashorn/api/scripting/resources/engine.js	Mon Jun 03 23:24:36 2013 -0700
    10.3 @@ -88,7 +88,7 @@
    10.4              }
    10.5          }
    10.6  
    10.7 -        array = Java.toJavaArray(array);
    10.8 +        array = Java.to(array);
    10.9          return Packages.jdk.nashorn.api.scripting.ScriptUtils.format(format, array);
   10.10      }
   10.11  });

    11.1 --- a/src/jdk/nashorn/internal/codegen/Attr.java	Thu May 30 10:58:35 2013 -0700
    11.2 +++ b/src/jdk/nashorn/internal/codegen/Attr.java	Mon Jun 03 23:24:36 2013 -0700
    11.3 @@ -84,8 +84,8 @@
    11.4  import jdk.nashorn.internal.ir.UnaryNode;
    11.5  import jdk.nashorn.internal.ir.VarNode;
    11.6  import jdk.nashorn.internal.ir.WithNode;
    11.7 +import jdk.nashorn.internal.ir.visitor.NodeVisitor;
    11.8  import jdk.nashorn.internal.ir.visitor.NodeOperatorVisitor;
    11.9 -import jdk.nashorn.internal.ir.visitor.NodeVisitor;
   11.10  import jdk.nashorn.internal.parser.TokenType;
   11.11  import jdk.nashorn.internal.runtime.Context;
   11.12  import jdk.nashorn.internal.runtime.Debug;
   11.13 @@ -111,7 +111,7 @@
   11.14   * computed.
   11.15   */
   11.16  
   11.17 -final class Attr extends NodeOperatorVisitor {
   11.18 +final class Attr extends NodeOperatorVisitor<LexicalContext> {
   11.19  
   11.20      /**
   11.21       * Local definitions in current block (to discriminate from function
   11.22 @@ -138,6 +138,7 @@
   11.23       * Constructor.
   11.24       */
   11.25      Attr(final TemporarySymbols temporarySymbols) {
   11.26 +        super(new LexicalContext());
   11.27          this.temporarySymbols = temporarySymbols;
   11.28          this.localDefs   = new ArrayDeque<>();
   11.29          this.localUses   = new ArrayDeque<>();
   11.30 @@ -202,7 +203,7 @@
   11.31      private void acceptDeclarations(final FunctionNode functionNode, final Block body) {
   11.32          // This visitor will assign symbol to all declared variables, except function declarations (which are taken care
   11.33          // in a separate step above) and "var" declarations in for loop initializers.
   11.34 -        body.accept(new NodeOperatorVisitor() {
   11.35 +        body.accept(new NodeVisitor<LexicalContext>(new LexicalContext()) {
   11.36              @Override
   11.37              public boolean enterFunctionNode(final FunctionNode nestedFn) {
   11.38                  return false;
   11.39 @@ -218,7 +219,7 @@
   11.40                      if (varNode.isFunctionDeclaration()) {
   11.41                          newType(symbol, FunctionNode.FUNCTION_TYPE);
   11.42                      }
   11.43 -                    return varNode.setName((IdentNode)ident.setSymbol(getLexicalContext(), symbol));
   11.44 +                    return varNode.setName((IdentNode)ident.setSymbol(lc, symbol));
   11.45                  }
   11.46                  return varNode;
   11.47              }
   11.48 @@ -227,8 +228,8 @@
   11.49  
   11.50      private void enterFunctionBody() {
   11.51  
   11.52 -        final FunctionNode functionNode = getLexicalContext().getCurrentFunction();
   11.53 -        final Block body = getLexicalContext().getCurrentBlock();
   11.54 +        final FunctionNode functionNode = lc.getCurrentFunction();
   11.55 +        final Block body = lc.getCurrentBlock();
   11.56  
   11.57          initFunctionWideVariables(functionNode, body);
   11.58  
   11.59 @@ -256,7 +257,7 @@
   11.60          //the symbols in the block should really be stateless
   11.61          block.clearSymbols();
   11.62  
   11.63 -        if (getLexicalContext().isFunctionBody()) {
   11.64 +        if (lc.isFunctionBody()) {
   11.65              enterFunctionBody();
   11.66          }
   11.67          pushLocalsBlock();
   11.68 @@ -283,7 +284,7 @@
   11.69      @Override
   11.70      public boolean enterCatchNode(final CatchNode catchNode) {
   11.71          final IdentNode exception = catchNode.getException();
   11.72 -        final Block     block     = getLexicalContext().getCurrentBlock();
   11.73 +        final Block     block     = lc.getCurrentBlock();
   11.74  
   11.75          start(catchNode);
   11.76  
   11.77 @@ -298,10 +299,10 @@
   11.78      @Override
   11.79      public Node leaveCatchNode(final CatchNode catchNode) {
   11.80          final IdentNode exception = catchNode.getException();
   11.81 -        final Block  block        = getLexicalContext().getCurrentBlock();
   11.82 +        final Block  block        = lc.getCurrentBlock();
   11.83          final Symbol symbol       = findSymbol(block, exception.getName());
   11.84          assert symbol != null;
   11.85 -        return end(catchNode.setException((IdentNode)exception.setSymbol(getLexicalContext(), symbol)));
   11.86 +        return end(catchNode.setException((IdentNode)exception.setSymbol(lc, symbol)));
   11.87      }
   11.88  
   11.89      /**
   11.90 @@ -320,7 +321,7 @@
   11.91              flags |= IS_SCOPE;
   11.92          }
   11.93  
   11.94 -        final FunctionNode function = getLexicalContext().getFunction(block);
   11.95 +        final FunctionNode function = lc.getFunction(block);
   11.96          if (symbol != null) {
   11.97              // Symbol was already defined. Check if it needs to be redefined.
   11.98              if ((flags & KINDMASK) == IS_PARAM) {
   11.99 @@ -353,12 +354,12 @@
  11.100              if ((flags & Symbol.KINDMASK) == IS_VAR && ((flags & IS_INTERNAL) == IS_INTERNAL || (flags & IS_LET) == IS_LET)) {
  11.101                  symbolBlock = block; //internal vars are always defined in the block closest to them
  11.102              } else {
  11.103 -                symbolBlock = getLexicalContext().getFunctionBody(function);
  11.104 +                symbolBlock = lc.getFunctionBody(function);
  11.105              }
  11.106  
  11.107              // Create and add to appropriate block.
  11.108              symbol = new Symbol(name, flags);
  11.109 -            symbolBlock.putSymbol(getLexicalContext(), symbol);
  11.110 +            symbolBlock.putSymbol(lc, symbol);
  11.111  
  11.112              if ((flags & Symbol.KINDMASK) != IS_GLOBAL) {
  11.113                  symbol.setNeedsSlot(true);
  11.114 @@ -381,7 +382,7 @@
  11.115          //an outermost function in our lexical context that is not a program (runScript)
  11.116          //is possible - it is a function being compiled lazily
  11.117          if (functionNode.isDeclared()) {
  11.118 -            final Iterator<Block> blocks = getLexicalContext().getBlocks();
  11.119 +            final Iterator<Block> blocks = lc.getBlocks();
  11.120              if (blocks.hasNext()) {
  11.121                  defineSymbol(blocks.next(), functionNode.getIdent().getName(), IS_VAR);
  11.122              }
  11.123 @@ -397,13 +398,11 @@
  11.124      public Node leaveFunctionNode(final FunctionNode functionNode) {
  11.125          FunctionNode newFunctionNode = functionNode;
  11.126  
  11.127 -        final LexicalContext lc = getLexicalContext();
  11.128 -
  11.129          final Block body = newFunctionNode.getBody();
  11.130  
  11.131          //look for this function in the parent block
  11.132          if (functionNode.isDeclared()) {
  11.133 -            final Iterator<Block> blocks = getLexicalContext().getBlocks();
  11.134 +            final Iterator<Block> blocks = lc.getBlocks();
  11.135              if (blocks.hasNext()) {
  11.136                  newFunctionNode = (FunctionNode)newFunctionNode.setSymbol(lc, findSymbol(blocks.next(), functionNode.getIdent().getName()));
  11.137              }
  11.138 @@ -411,7 +410,7 @@
  11.139              final boolean anonymous = functionNode.isAnonymous();
  11.140              final String  name      = anonymous ? null : functionNode.getIdent().getName();
  11.141              if (anonymous || body.getExistingSymbol(name) != null) {
  11.142 -                newFunctionNode = (FunctionNode)ensureSymbol(lc, FunctionNode.FUNCTION_TYPE, newFunctionNode);
  11.143 +                newFunctionNode = (FunctionNode)ensureSymbol(FunctionNode.FUNCTION_TYPE, newFunctionNode);
  11.144              } else {
  11.145                  assert name != null;
  11.146                  final Symbol self = body.getExistingSymbol(name);
  11.147 @@ -490,8 +489,6 @@
  11.148  
  11.149          start(identNode);
  11.150  
  11.151 -        final LexicalContext lc = getLexicalContext();
  11.152 -
  11.153          if (identNode.isPropertyName()) {
  11.154              // assign a pseudo symbol to property name
  11.155              final Symbol pseudoSymbol = pseudoSymbol(name);
  11.156 @@ -549,7 +546,7 @@
  11.157       */
  11.158      private void maybeForceScope(final Symbol symbol) {
  11.159          if (!symbol.isScope() && symbolNeedsToBeScope(symbol)) {
  11.160 -            Symbol.setSymbolIsScope(getLexicalContext(), symbol);
  11.161 +            Symbol.setSymbolIsScope(lc, symbol);
  11.162          }
  11.163      }
  11.164  
  11.165 @@ -558,7 +555,7 @@
  11.166              return false;
  11.167          }
  11.168          boolean previousWasBlock = false;
  11.169 -        for(final Iterator<LexicalContextNode> it = getLexicalContext().getAllNodes(); it.hasNext();) {
  11.170 +        for(final Iterator<LexicalContextNode> it = lc.getAllNodes(); it.hasNext();) {
  11.171              final LexicalContextNode node = it.next();
  11.172              if(node instanceof FunctionNode) {
  11.173                  // We reached the function boundary without seeing a definition for the symbol - it needs to be in
  11.174 @@ -594,10 +591,8 @@
  11.175          }
  11.176  
  11.177          if (symbol.isScope()) {
  11.178 -            final LexicalContext lc = getLexicalContext();
  11.179 -
  11.180              Block scopeBlock = null;
  11.181 -            for (final Iterator<LexicalContextNode> contextNodeIter = getLexicalContext().getAllNodes(); contextNodeIter.hasNext(); ) {
  11.182 +            for (final Iterator<LexicalContextNode> contextNodeIter = lc.getAllNodes(); contextNodeIter.hasNext(); ) {
  11.183                  final LexicalContextNode node = contextNodeIter.next();
  11.184                  if (node instanceof Block) {
  11.185                      if (((Block)node).getExistingSymbol(name) != null) {
  11.186 @@ -610,7 +605,7 @@
  11.187              }
  11.188  
  11.189              if (scopeBlock != null) {
  11.190 -                assert getLexicalContext().contains(scopeBlock);
  11.191 +                assert lc.contains(scopeBlock);
  11.192                  lc.setFlag(scopeBlock, Block.NEEDS_SCOPE);
  11.193              }
  11.194          }
  11.195 @@ -622,8 +617,8 @@
  11.196       * @see #needsParentScope()
  11.197       */
  11.198      private void setUsesGlobalSymbol() {
  11.199 -        for (final Iterator<FunctionNode> fns = getLexicalContext().getFunctions(); fns.hasNext();) {
  11.200 -            getLexicalContext().setFlag(fns.next(), FunctionNode.USES_ANCESTOR_SCOPE);
  11.201 +        for (final Iterator<FunctionNode> fns = lc.getFunctions(); fns.hasNext();) {
  11.202 +            lc.setFlag(fns.next(), FunctionNode.USES_ANCESTOR_SCOPE);
  11.203          }
  11.204      }
  11.205  
  11.206 @@ -635,7 +630,7 @@
  11.207      private Symbol findSymbol(final Block block, final String name) {
  11.208          // Search up block chain to locate symbol.
  11.209  
  11.210 -        for (final Iterator<Block> blocks = getLexicalContext().getBlocks(block); blocks.hasNext();) {
  11.211 +        for (final Iterator<Block> blocks = lc.getBlocks(block); blocks.hasNext();) {
  11.212              // Find name.
  11.213              final Symbol symbol = blocks.next().getExistingSymbol(name);
  11.214              // If found then we are good.
  11.215 @@ -656,11 +651,11 @@
  11.216      public Node leaveLiteralNode(final LiteralNode literalNode) {
  11.217          assert !literalNode.isTokenType(TokenType.THIS) : "tokentype for " + literalNode + " is this"; //guard against old dead code case. literal nodes should never inherit tokens
  11.218          assert literalNode instanceof ArrayLiteralNode || !(literalNode.getValue() instanceof Node) : "literals with Node values not supported";
  11.219 -        final Symbol symbol = new Symbol(getLexicalContext().getCurrentFunction().uniqueName(LITERAL_PREFIX.symbolName()), IS_CONSTANT, literalNode.getType());
  11.220 +        final Symbol symbol = new Symbol(lc.getCurrentFunction().uniqueName(LITERAL_PREFIX.symbolName()), IS_CONSTANT, literalNode.getType());
  11.221          if (literalNode instanceof ArrayLiteralNode) {
  11.222              ((ArrayLiteralNode)literalNode).analyze();
  11.223          }
  11.224 -        return end(literalNode.setSymbol(getLexicalContext(), symbol));
  11.225 +        return end(literalNode.setSymbol(lc, symbol));
  11.226      }
  11.227  
  11.228      @Override
  11.229 @@ -676,7 +671,7 @@
  11.230      @Override
  11.231      public Node leavePropertyNode(final PropertyNode propertyNode) {
  11.232          // assign a pseudo symbol to property name, see NASHORN-710
  11.233 -        return propertyNode.setSymbol(getLexicalContext(), new Symbol(propertyNode.getKeyName(), 0, Type.OBJECT));
  11.234 +        return propertyNode.setSymbol(lc, new Symbol(propertyNode.getKeyName(), 0, Type.OBJECT));
  11.235      }
  11.236  
  11.237      @Override
  11.238 @@ -734,11 +729,11 @@
  11.239              type = Type.OBJECT;
  11.240          }
  11.241  
  11.242 -        switchNode.setTag(newInternal(getLexicalContext().getCurrentFunction().uniqueName(SWITCH_TAG_PREFIX.symbolName()), type));
  11.243 +        switchNode.setTag(newInternal(lc.getCurrentFunction().uniqueName(SWITCH_TAG_PREFIX.symbolName()), type));
  11.244  
  11.245          end(switchNode);
  11.246  
  11.247 -        return switchNode.setCases(getLexicalContext(), newCases);
  11.248 +        return switchNode.setCases(lc, newCases);
  11.249      }
  11.250  
  11.251      @Override
  11.252 @@ -761,7 +756,7 @@
  11.253          final IdentNode ident = varNode.getName();
  11.254          final String    name  = ident.getName();
  11.255  
  11.256 -        final Symbol symbol = defineSymbol(getLexicalContext().getCurrentBlock(), name, IS_VAR);
  11.257 +        final Symbol symbol = defineSymbol(lc.getCurrentBlock(), name, IS_VAR);
  11.258          assert symbol != null;
  11.259  
  11.260          // NASHORN-467 - use before definition of vars - conservative
  11.261 @@ -781,7 +776,6 @@
  11.262          final IdentNode ident = newVarNode.getName();
  11.263          final String    name  = ident.getName();
  11.264  
  11.265 -        final LexicalContext lc = getLexicalContext();
  11.266          final Symbol  symbol = findSymbol(lc.getCurrentBlock(), ident.getName());
  11.267  
  11.268          if (init == null) {
  11.269 @@ -834,7 +828,7 @@
  11.270  
  11.271      @Override
  11.272      public Node leaveDELETE(final UnaryNode unaryNode) {
  11.273 -        final FunctionNode   currentFunctionNode = getLexicalContext().getCurrentFunction();
  11.274 +        final FunctionNode   currentFunctionNode = lc.getCurrentFunction();
  11.275          final boolean        strictMode          = currentFunctionNode.isStrict();
  11.276          final Node           rhs                 = unaryNode.rhs();
  11.277          final Node           strictFlagNode      = LiteralNode.newInstance(unaryNode, strictMode).accept(this);
  11.278 @@ -894,10 +888,10 @@
  11.279       * @return true if the symbol denoted by the specified name in the current lexical context defined in the program level.
  11.280       */
  11.281      private boolean isProgramLevelSymbol(final String name) {
  11.282 -        for(final Iterator<Block> it = getLexicalContext().getBlocks(); it.hasNext();) {
  11.283 +        for(final Iterator<Block> it = lc.getBlocks(); it.hasNext();) {
  11.284              final Block next = it.next();
  11.285              if(next.getExistingSymbol(name) != null) {
  11.286 -                return next == getLexicalContext().getFunctionBody(getLexicalContext().getOutermostFunction());
  11.287 +                return next == lc.getFunctionBody(lc.getOutermostFunction());
  11.288              }
  11.289          }
  11.290          throw new AssertionError("Couldn't find symbol " + name + " in the context");
  11.291 @@ -914,14 +908,14 @@
  11.292      }
  11.293  
  11.294      private IdentNode compilerConstant(CompilerConstants cc) {
  11.295 -        final FunctionNode functionNode = getLexicalContext().getCurrentFunction();
  11.296 +        final FunctionNode functionNode = lc.getCurrentFunction();
  11.297          return (IdentNode)
  11.298              new IdentNode(
  11.299                  functionNode.getToken(),
  11.300                  functionNode.getFinish(),
  11.301                  cc.symbolName()).
  11.302                  setSymbol(
  11.303 -                    getLexicalContext(),
  11.304 +                    lc,
  11.305                      functionNode.compilerConstant(cc));
  11.306      }
  11.307  
  11.308 @@ -999,7 +993,7 @@
  11.309          final Node lhs = binaryNode.lhs();
  11.310  
  11.311          if (lhs instanceof IdentNode) {
  11.312 -            final Block     block = getLexicalContext().getCurrentBlock();
  11.313 +            final Block     block = lc.getCurrentBlock();
  11.314              final IdentNode ident = (IdentNode)lhs;
  11.315              final String    name  = ident.getName();
  11.316  
  11.317 @@ -1043,7 +1037,7 @@
  11.318      }
  11.319  
  11.320      private boolean isLocal(FunctionNode function, Symbol symbol) {
  11.321 -        final FunctionNode definingFn = getLexicalContext().getDefiningFunction(symbol);
  11.322 +        final FunctionNode definingFn = lc.getDefiningFunction(symbol);
  11.323          // Temp symbols are not assigned to a block, so their defining fn is null; those can be assumed local
  11.324          return definingFn == null || definingFn == function;
  11.325      }
  11.326 @@ -1329,7 +1323,7 @@
  11.327      @Override
  11.328      public Node leaveForNode(final ForNode forNode) {
  11.329          if (forNode.isForIn()) {
  11.330 -            forNode.setIterator(newInternal(getLexicalContext().getCurrentFunction().uniqueName(ITERATOR_PREFIX.symbolName()), Type.OBJECT)); //NASHORN-73
  11.331 +            forNode.setIterator(newInternal(lc.getCurrentFunction().uniqueName(ITERATOR_PREFIX.symbolName()), Type.OBJECT)); //NASHORN-73
  11.332              /*
  11.333               * Iterators return objects, so we need to widen the scope of the
  11.334               * init variable if it, for example, has been assigned double type
  11.335 @@ -1407,7 +1401,7 @@
  11.336              final Symbol paramSymbol = functionNode.getBody().getExistingSymbol(param.getName());
  11.337              assert paramSymbol != null;
  11.338              assert paramSymbol.isParam();
  11.339 -            newParams.add((IdentNode)param.setSymbol(getLexicalContext(), paramSymbol));
  11.340 +            newParams.add((IdentNode)param.setSymbol(lc, paramSymbol));
  11.341  
  11.342              assert paramSymbol != null;
  11.343              Type type = functionNode.getHints().getParameterType(pos);
  11.344 @@ -1439,10 +1433,10 @@
  11.345          FunctionNode newFunctionNode = functionNode;
  11.346  
  11.347          if (nparams == 0 || (specialize * 2) < nparams) {
  11.348 -            newFunctionNode = newFunctionNode.clearSnapshot(getLexicalContext());
  11.349 +            newFunctionNode = newFunctionNode.clearSnapshot(lc);
  11.350          }
  11.351  
  11.352 -        return newFunctionNode.setParameters(getLexicalContext(), newParams);
  11.353 +        return newFunctionNode.setParameters(lc, newParams);
  11.354      }
  11.355  
  11.356      /**
  11.357 @@ -1506,7 +1500,7 @@
  11.358      }
  11.359  
  11.360      private Symbol exceptionSymbol() {
  11.361 -        return newInternal(getLexicalContext().getCurrentFunction().uniqueName(EXCEPTION_PREFIX.symbolName()), Type.typeFor(ECMAException.class));
  11.362 +        return newInternal(lc.getCurrentFunction().uniqueName(EXCEPTION_PREFIX.symbolName()), Type.typeFor(ECMAException.class));
  11.363      }
  11.364  
  11.365      /**
  11.366 @@ -1520,8 +1514,8 @@
  11.367       * @param assignmentDest the destination node of the assignment, e.g. lhs for binary nodes
  11.368       */
  11.369      private Node ensureAssignmentSlots(final Node assignmentDest) {
  11.370 -        final LexicalContext attrLexicalContext = getLexicalContext();
  11.371 -        return assignmentDest.accept(new NodeVisitor() {
  11.372 +        final LexicalContext attrLexicalContext = lc;
  11.373 +        return assignmentDest.accept(new NodeVisitor<LexicalContext>(new LexicalContext()) {
  11.374              @Override
  11.375              public Node leaveIndexNode(final IndexNode indexNode) {
  11.376                  assert indexNode.getSymbol().isTemp();
  11.377 @@ -1565,7 +1559,7 @@
  11.378          FunctionNode currentFunctionNode = functionNode;
  11.379          do {
  11.380              changed.clear();
  11.381 -            final FunctionNode newFunctionNode = (FunctionNode)currentFunctionNode.accept(new NodeVisitor() {
  11.382 +            final FunctionNode newFunctionNode = (FunctionNode)currentFunctionNode.accept(new NodeVisitor<LexicalContext>(new LexicalContext()) {
  11.383  
  11.384                  private Node widen(final Node node, final Type to) {
  11.385                      if (node instanceof LiteralNode) {
  11.386 @@ -1579,7 +1573,7 @@
  11.387                              symbol = temporarySymbols.getTypedTemporarySymbol(to);
  11.388                          }
  11.389                          newType(symbol, to);
  11.390 -                        final Node newNode = node.setSymbol(getLexicalContext(), symbol);
  11.391 +                        final Node newNode = node.setSymbol(lc, symbol);
  11.392                          changed.add(newNode);
  11.393                          return newNode;
  11.394                      }
  11.395 @@ -1622,7 +1616,7 @@
  11.396                      return newBinaryNode;
  11.397                  }
  11.398              });
  11.399 -            getLexicalContext().replace(currentFunctionNode, newFunctionNode);
  11.400 +            lc.replace(currentFunctionNode, newFunctionNode);
  11.401              currentFunctionNode = newFunctionNode;
  11.402          } while (!changed.isEmpty());
  11.403          return currentFunctionNode;
  11.404 @@ -1643,12 +1637,12 @@
  11.405      }
  11.406  
  11.407      private Node ensureSymbol(final Type type, final Node node) {
  11.408 -        LOG.info("New TEMPORARY added to ", getLexicalContext().getCurrentFunction().getName(), " type=", type);
  11.409 -        return ensureSymbol(getLexicalContext(), type, node);
  11.410 +        LOG.info("New TEMPORARY added to ", lc.getCurrentFunction().getName(), " type=", type);
  11.411 +        return temporarySymbols.ensureSymbol(lc, type, node);
  11.412      }
  11.413  
  11.414      private Symbol newInternal(final String name, final Type type) {
  11.415 -        final Symbol iter = defineSymbol(getLexicalContext().getCurrentBlock(), name, IS_VAR | IS_INTERNAL);
  11.416 +        final Symbol iter = defineSymbol(lc.getCurrentBlock(), name, IS_VAR | IS_INTERNAL);
  11.417          iter.setType(type); // NASHORN-73
  11.418          return iter;
  11.419      }
  11.420 @@ -1705,10 +1699,6 @@
  11.421          localUses.peek().add(name);
  11.422      }
  11.423  
  11.424 -    private Node ensureSymbol(final LexicalContext lc, final Type type, final Node node) {
  11.425 -        return temporarySymbols.ensureSymbol(lc, type, node);
  11.426 -    }
  11.427 -
  11.428      /**
  11.429       * Pessimistically promote all symbols in current function node to Object types
  11.430       * This is done when the function contains unevaluated black boxes such as
  11.431 @@ -1717,7 +1707,7 @@
  11.432       * @param body body for the function node we are leaving
  11.433       */
  11.434      private static void objectifySymbols(final Block body) {
  11.435 -        body.accept(new NodeVisitor() {
  11.436 +        body.accept(new NodeVisitor<LexicalContext>(new LexicalContext()) {
  11.437              private void toObject(final Block block) {
  11.438                  for (final Symbol symbol : block.getSymbols()) {
  11.439                      if (!symbol.isTemp()) {
  11.440 @@ -1761,7 +1751,7 @@
  11.441                  append("] ").
  11.442                  append(printNode ? node.toString() : "").
  11.443                  append(" in '").
  11.444 -                append(getLexicalContext().getCurrentFunction().getName()).
  11.445 +                append(lc.getCurrentFunction().getName()).
  11.446                  append("'");
  11.447              LOG.info(sb);
  11.448              LOG.indent();
  11.449 @@ -1787,7 +1777,7 @@
  11.450                  append("] ").
  11.451                  append(printNode ? node.toString() : "").
  11.452                  append(" in '").
  11.453 -                append(getLexicalContext().getCurrentFunction().getName());
  11.454 +                append(lc.getCurrentFunction().getName());
  11.455  
  11.456              if (node.getSymbol() == null) {
  11.457                  sb.append(" <NO SYMBOL>");

    12.1 --- a/src/jdk/nashorn/internal/codegen/CodeGenerator.java	Thu May 30 10:58:35 2013 -0700
    12.2 +++ b/src/jdk/nashorn/internal/codegen/CodeGenerator.java	Mon Jun 03 23:24:36 2013 -0700
    12.3 @@ -52,16 +52,13 @@
    12.4  import static jdk.nashorn.internal.runtime.linker.NashornCallSiteDescriptor.CALLSITE_STRICT;
    12.5  
    12.6  import java.io.PrintWriter;
    12.7 -import java.util.ArrayDeque;
    12.8  import java.util.ArrayList;
    12.9  import java.util.Arrays;
   12.10 -import java.util.Deque;
   12.11  import java.util.EnumSet;
   12.12 -import java.util.HashMap;
   12.13  import java.util.Iterator;
   12.14  import java.util.LinkedList;
   12.15  import java.util.List;
   12.16 -import java.util.Map;
   12.17 +import java.util.Locale;
   12.18  import java.util.TreeMap;
   12.19  
   12.20  import jdk.nashorn.internal.codegen.ClassEmitter.Flag;
   12.21 @@ -83,11 +80,11 @@
   12.22  import jdk.nashorn.internal.ir.ExecuteNode;
   12.23  import jdk.nashorn.internal.ir.ForNode;
   12.24  import jdk.nashorn.internal.ir.FunctionNode;
   12.25 +import jdk.nashorn.internal.ir.LexicalContext;
   12.26  import jdk.nashorn.internal.ir.FunctionNode.CompilationState;
   12.27  import jdk.nashorn.internal.ir.IdentNode;
   12.28  import jdk.nashorn.internal.ir.IfNode;
   12.29  import jdk.nashorn.internal.ir.IndexNode;
   12.30 -import jdk.nashorn.internal.ir.LexicalContext;
   12.31  import jdk.nashorn.internal.ir.LexicalContextNode;
   12.32  import jdk.nashorn.internal.ir.LiteralNode;
   12.33  import jdk.nashorn.internal.ir.LiteralNode.ArrayLiteralNode;
   12.34 @@ -150,7 +147,7 @@
   12.35   * The CodeGenerator visits nodes only once, tags them as resolved and emits
   12.36   * bytecode for them.
   12.37   */
   12.38 -final class CodeGenerator extends NodeOperatorVisitor {
   12.39 +final class CodeGenerator extends NodeOperatorVisitor<CodeGeneratorLexicalContext> {
   12.40  
   12.41      /** Name of the Global object, cannot be referred to as .class, @see CodeGenerator */
   12.42      private static final String GLOBAL_OBJECT = Compiler.OBJECTS_PACKAGE + '/' + "Global";
   12.43 @@ -168,23 +165,12 @@
   12.44      /** How many regexp fields have been emitted */
   12.45      private int regexFieldCount;
   12.46  
   12.47 -    /** Map of shared scope call sites */
   12.48 -    private final Map<SharedScopeCall, SharedScopeCall> scopeCalls = new HashMap<>();
   12.49 -
   12.50 -    /** Compile unit stack - every time we start a sub method (e.g. a split) we push one */
   12.51 -    private final Deque<CompileUnit> compileUnits = new ArrayDeque<>();
   12.52 -
   12.53 -    /** Method emitter stack - every time we start a sub method (e.g. a split) we push one */
   12.54 -    private final Deque<MethodEmitter> methodEmitters = new ArrayDeque<>();
   12.55 -
   12.56 -    /** The discard stack - whenever we enter a discard node we keep track of its return value status -
   12.57 -     *  i.e. should we keep it or throw it away */
   12.58 -    private final Deque<Node> discard = new ArrayDeque<>();
   12.59 -
   12.60 -    // A stack tracking the next free local variable slot in the blocks. There's one entry for every block
   12.61 -    // currently on the lexical context stack.
   12.62 -    private int[] nextFreeSlots = new int[16];
   12.63 -    private int nextFreeSlotsSize = 0;
   12.64 +    /** Line number for last statement. If we encounter a new line number, line number bytecode information
   12.65 +     *  needs to be generated */
   12.66 +    private int lastLineNumber = -1;
   12.67 +
   12.68 +    /** When should we stop caching regexp expressions in fields to limit bytecode size? */
   12.69 +    private static final int MAX_REGEX_FIELDS = 2 * 1024;
   12.70  
   12.71      /** Current method emitter */
   12.72      private MethodEmitter method;
   12.73 @@ -192,20 +178,16 @@
   12.74      /** Current compile unit */
   12.75      private CompileUnit unit;
   12.76  
   12.77 -    private int lastLineNumber = -1;
   12.78 -
   12.79 -    /** When should we stop caching regexp expressions in fields to limit bytecode size? */
   12.80 -    private static final int MAX_REGEX_FIELDS = 2 * 1024;
   12.81 -
   12.82      private static final DebugLogger LOG   = new DebugLogger("codegen", "nashorn.codegen.debug");
   12.83  
   12.84 +
   12.85      /**
   12.86       * Constructor.
   12.87       *
   12.88       * @param compiler
   12.89       */
   12.90      CodeGenerator(final Compiler compiler) {
   12.91 -        super(new DynamicScopeTrackingLexicalContext());
   12.92 +        super(new CodeGeneratorLexicalContext());
   12.93          this.compiler      = compiler;
   12.94          this.callSiteFlags = compiler.getEnv()._callsite_flags;
   12.95      }
   12.96 @@ -217,37 +199,7 @@
   12.97       * @return the correct flags for a call site in the current function
   12.98       */
   12.99      int getCallSiteFlags() {
  12.100 -        return getLexicalContext().getCurrentFunction().isStrict() ? callSiteFlags | CALLSITE_STRICT : callSiteFlags;
  12.101 -    }
  12.102 -
  12.103 -    private void pushMethodEmitter(final MethodEmitter newMethod) {
  12.104 -        methodEmitters.push(newMethod);
  12.105 -        this.method = newMethod;
  12.106 -    }
  12.107 -
  12.108 -    private void popMethodEmitter(final MethodEmitter oldMethod) {
  12.109 -        assert methodEmitters.peek() == oldMethod;
  12.110 -        methodEmitters.pop();
  12.111 -        if (!methodEmitters.isEmpty()) {
  12.112 -            this.method = methodEmitters.peek();
  12.113 -        } else {
  12.114 -            this.method = null;
  12.115 -        }
  12.116 -    }
  12.117 -
  12.118 -    private void push(final CompileUnit newUnit) {
  12.119 -        compileUnits.push(newUnit);
  12.120 -        this.unit = newUnit;
  12.121 -    }
  12.122 -
  12.123 -    private void pop(final CompileUnit oldUnit) {
  12.124 -        assert compileUnits.peek() == oldUnit;
  12.125 -        compileUnits.pop();
  12.126 -        if (!compileUnits.isEmpty()) {
  12.127 -            this.unit = compileUnits.peek();
  12.128 -        } else {
  12.129 -            this.unit = null;
  12.130 -        }
  12.131 +        return lc.getCurrentFunction().isStrict() ? callSiteFlags | CALLSITE_STRICT : callSiteFlags;
  12.132      }
  12.133  
  12.134      /**
  12.135 @@ -265,7 +217,7 @@
  12.136          }
  12.137  
  12.138          final String name   = symbol.getName();
  12.139 -        final Source source = getLexicalContext().getCurrentFunction().getSource();
  12.140 +        final Source source = lc.getCurrentFunction().getSource();
  12.141  
  12.142          if (CompilerConstants.__FILE__.name().equals(name)) {
  12.143              return method.load(source.getName());
  12.144 @@ -291,88 +243,43 @@
  12.145      }
  12.146  
  12.147      /**
  12.148 -     * A lexical context that also tracks if we have any dynamic scopes in the context. Such scopes can have new
  12.149 -     * variables introduced into them at run time - a with block or a function directly containing an eval call.
  12.150 -     */
  12.151 -    private static class DynamicScopeTrackingLexicalContext extends LexicalContext {
  12.152 -        int dynamicScopeCount = 0;
  12.153 -
  12.154 -        @Override
  12.155 -        public <T extends LexicalContextNode> T push(T node) {
  12.156 -            if(isDynamicScopeBoundary(node)) {
  12.157 -                ++dynamicScopeCount;
  12.158 -            }
  12.159 -            return super.push(node);
  12.160 -        }
  12.161 -
  12.162 -        @Override
  12.163 -        public <T extends LexicalContextNode> T pop(T node) {
  12.164 -            final T popped = super.pop(node);
  12.165 -            if(isDynamicScopeBoundary(popped)) {
  12.166 -                --dynamicScopeCount;
  12.167 -            }
  12.168 -            return popped;
  12.169 -        }
  12.170 -
  12.171 -        private boolean isDynamicScopeBoundary(LexicalContextNode node) {
  12.172 -            if(node instanceof Block) {
  12.173 -                // Block's immediate parent is a with node. Note we aren't testing for a WithNode, as that'd capture
  12.174 -                // processing of WithNode.expression too, but it should be unaffected.
  12.175 -                return !isEmpty() && peek() instanceof WithNode;
  12.176 -            } else if(node instanceof FunctionNode) {
  12.177 -                // Function has a direct eval in it (so a top-level "var ..." in the eval code can introduce a new
  12.178 -                // variable into the function's scope), and it isn't strict (as evals in strict functions get an
  12.179 -                // isolated scope).
  12.180 -                return isFunctionDynamicScope((FunctionNode)node);
  12.181 -            }
  12.182 -            return false;
  12.183 -        }
  12.184 -    }
  12.185 -
  12.186 -    boolean inDynamicScope() {
  12.187 -        return ((DynamicScopeTrackingLexicalContext)getLexicalContext()).dynamicScopeCount > 0;
  12.188 -    }
  12.189 -
  12.190 -    static boolean isFunctionDynamicScope(FunctionNode fn) {
  12.191 -        return fn.hasEval() && !fn.isStrict();
  12.192 -    }
  12.193 -
  12.194 -    /**
  12.195       * Check if this symbol can be accessed directly with a putfield or getfield or dynamic load
  12.196       *
  12.197       * @param function function to check for fast scope
  12.198       * @return true if fast scope
  12.199       */
  12.200      private boolean isFastScope(final Symbol symbol) {
  12.201 -        if(!symbol.isScope()) {
  12.202 +        if (!symbol.isScope()) {
  12.203              return false;
  12.204          }
  12.205 -        final LexicalContext lc = getLexicalContext();
  12.206 -        if(!inDynamicScope()) {
  12.207 +
  12.208 +        if (!lc.inDynamicScope()) {
  12.209              // If there's no with or eval in context, and the symbol is marked as scoped, it is fast scoped. Such a
  12.210              // symbol must either be global, or its defining block must need scope.
  12.211              assert symbol.isGlobal() || lc.getDefiningBlock(symbol).needsScope() : symbol.getName();
  12.212              return true;
  12.213          }
  12.214 -        if(symbol.isGlobal()) {
  12.215 +
  12.216 +        if (symbol.isGlobal()) {
  12.217              // Shortcut: if there's a with or eval in context, globals can't be fast scoped
  12.218              return false;
  12.219          }
  12.220 +
  12.221          // Otherwise, check if there's a dynamic scope between use of the symbol and its definition
  12.222          final String name = symbol.getName();
  12.223          boolean previousWasBlock = false;
  12.224          for (final Iterator<LexicalContextNode> it = lc.getAllNodes(); it.hasNext();) {
  12.225              final LexicalContextNode node = it.next();
  12.226 -            if(node instanceof Block) {
  12.227 +            if (node instanceof Block) {
  12.228                  // If this block defines the symbol, then we can fast scope the symbol.
  12.229                  final Block block = (Block)node;
  12.230 -                if(block.getExistingSymbol(name) == symbol) {
  12.231 +                if (block.getExistingSymbol(name) == symbol) {
  12.232                      assert block.needsScope();
  12.233                      return true;
  12.234                  }
  12.235                  previousWasBlock = true;
  12.236              } else {
  12.237 -                if((node instanceof WithNode && previousWasBlock) || (node instanceof FunctionNode && isFunctionDynamicScope((FunctionNode)node))) {
  12.238 +                if ((node instanceof WithNode && previousWasBlock) || (node instanceof FunctionNode && CodeGeneratorLexicalContext.isFunctionDynamicScope((FunctionNode)node))) {
  12.239                      // If we hit a scope that can have symbols introduced into it at run time before finding the defining
  12.240                      // block, the symbol can't be fast scoped. A WithNode only counts if we've immediately seen a block
  12.241                      // before - its block. Otherwise, we are currently processing the WithNode's expression, and that's
  12.242 @@ -387,16 +294,14 @@
  12.243      }
  12.244  
  12.245      private MethodEmitter loadSharedScopeVar(final Type valueType, final Symbol symbol, final int flags) {
  12.246 -        method.load(isFastScope(symbol) ? getScopeProtoDepth(getLexicalContext().getCurrentBlock(), symbol) : -1);
  12.247 -        final SharedScopeCall scopeCall = getScopeGet(valueType, symbol, flags | CALLSITE_FAST_SCOPE);
  12.248 -        scopeCall.generateInvoke(method);
  12.249 -        return method;
  12.250 +        method.load(isFastScope(symbol) ? getScopeProtoDepth(lc.getCurrentBlock(), symbol) : -1);
  12.251 +        final SharedScopeCall scopeCall = lc.getScopeGet(unit, valueType, symbol, flags | CALLSITE_FAST_SCOPE);
  12.252 +        return scopeCall.generateInvoke(method);
  12.253      }
  12.254  
  12.255      private MethodEmitter loadFastScopeVar(final Type valueType, final Symbol symbol, final int flags, final boolean isMethod) {
  12.256          loadFastScopeProto(symbol, false);
  12.257 -        method.dynamicGet(valueType, symbol.getName(), flags | CALLSITE_FAST_SCOPE, isMethod);
  12.258 -        return method;
  12.259 +        return method.dynamicGet(valueType, symbol.getName(), flags | CALLSITE_FAST_SCOPE, isMethod);
  12.260      }
  12.261  
  12.262      private MethodEmitter storeFastScopeVar(final Type valueType, final Symbol symbol, final int flags) {
  12.263 @@ -408,7 +313,7 @@
  12.264      private int getScopeProtoDepth(final Block startingBlock, final Symbol symbol) {
  12.265          int depth = 0;
  12.266          final String name = symbol.getName();
  12.267 -        for(final Iterator<Block> blocks = getLexicalContext().getBlocks(startingBlock); blocks.hasNext();) {
  12.268 +        for(final Iterator<Block> blocks = lc.getBlocks(startingBlock); blocks.hasNext();) {
  12.269              final Block currentBlock = blocks.next();
  12.270              if (currentBlock.getExistingSymbol(name) == symbol) {
  12.271                  return depth;
  12.272 @@ -421,7 +326,7 @@
  12.273      }
  12.274  
  12.275      private void loadFastScopeProto(final Symbol symbol, final boolean swap) {
  12.276 -        final int depth = getScopeProtoDepth(getLexicalContext().getCurrentBlock(), symbol);
  12.277 +        final int depth = getScopeProtoDepth(lc.getCurrentBlock(), symbol);
  12.278          assert depth != -1;
  12.279          if (depth > 0) {
  12.280              if (swap) {
  12.281 @@ -464,7 +369,7 @@
  12.282           */
  12.283          final CodeGenerator codegen = this;
  12.284  
  12.285 -        node.accept(new NodeVisitor() {
  12.286 +        node.accept(new NodeVisitor<LexicalContext>(new LexicalContext()) {
  12.287              @Override
  12.288              public boolean enterIdentNode(final IdentNode identNode) {
  12.289                  loadIdent(identNode);
  12.290 @@ -538,7 +443,7 @@
  12.291              final boolean isInternal = symbol.isParam() || symbol.isInternal() || symbol.isThis() || !symbol.canBeUndefined();
  12.292  
  12.293              if (symbol.hasSlot() && !isInternal) {
  12.294 -                assert symbol.getSymbolType().isNumber() || symbol.getSymbolType().isObject() : "no potentially undefined narrower local vars than doubles are allowed: " + symbol + " in " + getLexicalContext().getCurrentFunction();
  12.295 +                assert symbol.getSymbolType().isNumber() || symbol.getSymbolType().isObject() : "no potentially undefined narrower local vars than doubles are allowed: " + symbol + " in " + lc.getCurrentFunction();
  12.296                  if (symbol.getSymbolType().isNumber()) {
  12.297                      numbers.add(symbol);
  12.298                  } else if (symbol.getSymbolType().isObject()) {
  12.299 @@ -595,7 +500,6 @@
  12.300          if (block.needsScope() && !block.isTerminal()) {
  12.301              popBlockScope(block);
  12.302          }
  12.303 -        --nextFreeSlotsSize;
  12.304          return block;
  12.305      }
  12.306  
  12.307 @@ -624,11 +528,11 @@
  12.308      public boolean enterBreakNode(final BreakNode breakNode) {
  12.309          lineNumber(breakNode);
  12.310  
  12.311 -        final BreakableNode breakFrom = getLexicalContext().getBreakable(breakNode.getLabel());
  12.312 -        for (int i = 0; i < getLexicalContext().getScopeNestingLevelTo(breakFrom); i++) {
  12.313 +        final BreakableNode breakFrom = lc.getBreakable(breakNode.getLabel());
  12.314 +        for (int i = 0; i < lc.getScopeNestingLevelTo(breakFrom); i++) {
  12.315              closeWith();
  12.316          }
  12.317 -        method.splitAwareGoto(getLexicalContext(), breakFrom.getBreakLabel());
  12.318 +        method.splitAwareGoto(lc, breakFrom.getBreakLabel());
  12.319  
  12.320          return false;
  12.321      }
  12.322 @@ -672,11 +576,12 @@
  12.323  
  12.324          final List<Node>   args            = callNode.getArgs();
  12.325          final Node         function        = callNode.getFunction();
  12.326 -        final Block        currentBlock    = getLexicalContext().getCurrentBlock();
  12.327 -
  12.328 -        function.accept(new NodeVisitor() {
  12.329 -
  12.330 -            private void sharedScopeCall(final IdentNode identNode, final int flags) {
  12.331 +        final Block        currentBlock    = lc.getCurrentBlock();
  12.332 +        final CodeGeneratorLexicalContext codegenLexicalContext = lc;
  12.333 +
  12.334 +        function.accept(new NodeVisitor<LexicalContext>(new LexicalContext()) {
  12.335 +
  12.336 +            private MethodEmitter sharedScopeCall(final IdentNode identNode, final int flags) {
  12.337                  final Symbol symbol = identNode.getSymbol();
  12.338                  int    scopeCallFlags = flags;
  12.339                  method.loadCompilerConstant(SCOPE);
  12.340 @@ -688,8 +593,8 @@
  12.341                  }
  12.342                  loadArgs(args);
  12.343                  final Type[] paramTypes = method.getTypesFromStack(args.size());
  12.344 -                final SharedScopeCall scopeCall = getScopeCall(symbol, identNode.getType(), callNode.getType(), paramTypes, scopeCallFlags);
  12.345 -                scopeCall.generateInvoke(method);
  12.346 +                final SharedScopeCall scopeCall = codegenLexicalContext.getScopeCall(unit, symbol, identNode.getType(), callNode.getType(), paramTypes, scopeCallFlags);
  12.347 +                return scopeCall.generateInvoke(method);
  12.348              }
  12.349  
  12.350              private void scopeCall(final IdentNode node, final int flags) {
  12.351 @@ -756,7 +661,7 @@
  12.352                          evalCall(node, flags);
  12.353                      } else if (useCount <= SharedScopeCall.FAST_SCOPE_CALL_THRESHOLD
  12.354                              || (!isFastScope(symbol) && useCount <= SharedScopeCall.SLOW_SCOPE_CALL_THRESHOLD)
  12.355 -                            || CodeGenerator.this.inDynamicScope()) {
  12.356 +                            || CodeGenerator.this.lc.inDynamicScope()) {
  12.357                          scopeCall(node, flags);
  12.358                      } else {
  12.359                          sharedScopeCall(node, flags);
  12.360 @@ -845,11 +750,11 @@
  12.361      public boolean enterContinueNode(final ContinueNode continueNode) {
  12.362          lineNumber(continueNode);
  12.363  
  12.364 -        final LoopNode continueTo = getLexicalContext().getContinueTo(continueNode.getLabel());
  12.365 -        for (int i = 0; i < getLexicalContext().getScopeNestingLevelTo(continueTo); i++) {
  12.366 +        final LoopNode continueTo = lc.getContinueTo(continueNode.getLabel());
  12.367 +        for (int i = 0; i < lc.getScopeNestingLevelTo(continueTo); i++) {
  12.368              closeWith();
  12.369          }
  12.370 -        method.splitAwareGoto(getLexicalContext(), continueTo.getContinueLabel());
  12.371 +        method.splitAwareGoto(lc, continueTo.getContinueLabel());
  12.372  
  12.373          return false;
  12.374      }
  12.375 @@ -875,90 +780,89 @@
  12.376      public boolean enterForNode(final ForNode forNode) {
  12.377          lineNumber(forNode);
  12.378  
  12.379 +        if (forNode.isForIn()) {
  12.380 +            enterForIn(forNode);
  12.381 +        } else {
  12.382 +            enterFor(forNode);
  12.383 +        }
  12.384 +
  12.385 +        return false;
  12.386 +    }
  12.387 +
  12.388 +    private void enterFor(final ForNode forNode) {
  12.389 +        final Node  init   = forNode.getInit();
  12.390          final Node  test   = forNode.getTest();
  12.391          final Block body   = forNode.getBody();
  12.392          final Node  modify = forNode.getModify();
  12.393  
  12.394 -        final Label breakLabel    = forNode.getBreakLabel();
  12.395 -        final Label continueLabel = forNode.getContinueLabel();
  12.396 -        final Label loopLabel     = new Label("loop");
  12.397 +        if (init != null) {
  12.398 +            init.accept(this);
  12.399 +        }
  12.400 +
  12.401 +        final Label loopLabel = new Label("loop");
  12.402 +        final Label testLabel = new Label("test");
  12.403 +
  12.404 +        method._goto(testLabel);
  12.405 +        method.label(loopLabel);
  12.406 +        body.accept(this);
  12.407 +        method.label(forNode.getContinueLabel());
  12.408 +
  12.409 +        if (!body.isTerminal() && modify != null) {
  12.410 +            load(modify);
  12.411 +        }
  12.412 +
  12.413 +        method.label(testLabel);
  12.414 +        if (test != null) {
  12.415 +            new BranchOptimizer(this, method).execute(test, loopLabel, true);
  12.416 +        } else {
  12.417 +            method._goto(loopLabel);
  12.418 +        }
  12.419 +
  12.420 +        method.label(forNode.getBreakLabel());
  12.421 +    }
  12.422 +
  12.423 +    private void enterForIn(final ForNode forNode) {
  12.424 +        final Block body   = forNode.getBody();
  12.425 +        final Node  modify = forNode.getModify();
  12.426 +
  12.427 +        final Symbol iter      = forNode.getIterator();
  12.428 +        final Label  loopLabel = new Label("loop");
  12.429  
  12.430          Node init = forNode.getInit();
  12.431  
  12.432 -        if (forNode.isForIn()) {
  12.433 -            final Symbol iter = forNode.getIterator();
  12.434 -
  12.435 -            // We have to evaluate the optional initializer expression
  12.436 -            // of the iterator variable of the for-in statement.
  12.437 -            if (init instanceof VarNode) {
  12.438 -                init.accept(this);
  12.439 -                init = ((VarNode)init).getName();
  12.440 +        // We have to evaluate the optional initializer expression
  12.441 +        // of the iterator variable of the for-in statement.
  12.442 +        if (init instanceof VarNode) {
  12.443 +            init.accept(this);
  12.444 +            init = ((VarNode)init).getName();
  12.445 +        }
  12.446 +
  12.447 +        load(modify);
  12.448 +        assert modify.getType().isObject();
  12.449 +        method.invoke(forNode.isForEach() ? ScriptRuntime.TO_VALUE_ITERATOR : ScriptRuntime.TO_PROPERTY_ITERATOR);
  12.450 +        method.store(iter);
  12.451 +        method._goto(forNode.getContinueLabel());
  12.452 +        method.label(loopLabel);
  12.453 +
  12.454 +        new Store<Node>(init) {
  12.455 +            @Override
  12.456 +            protected void storeNonDiscard() {
  12.457 +                return;
  12.458              }
  12.459 -
  12.460 -            load(modify);
  12.461 -            assert modify.getType().isObject();
  12.462 -            method.invoke(forNode.isForEach() ? ScriptRuntime.TO_VALUE_ITERATOR : ScriptRuntime.TO_PROPERTY_ITERATOR);
  12.463 -            method.store(iter);
  12.464 -            method._goto(continueLabel);
  12.465 -            method.label(loopLabel);
  12.466 -
  12.467 -            new Store<Node>(init) {
  12.468 -                @Override
  12.469 -                protected void storeNonDiscard() {
  12.470 -                    return;
  12.471 -                }
  12.472 -                @Override
  12.473 -                protected void evaluate() {
  12.474 -                    method.load(iter);
  12.475 -                    method.invoke(interfaceCallNoLookup(Iterator.class, "next", Object.class));
  12.476 -                }
  12.477 -            }.store();
  12.478 -
  12.479 -            body.accept(this);
  12.480 -
  12.481 -            method.label(continueLabel);
  12.482 -            method.load(iter);
  12.483 -            method.invoke(interfaceCallNoLookup(Iterator.class, "hasNext", boolean.class));
  12.484 -            method.ifne(loopLabel);
  12.485 -            method.label(breakLabel);
  12.486 -        } else {
  12.487 -            if (init != null) {
  12.488 -                init.accept(this);
  12.489 +            @Override
  12.490 +            protected void evaluate() {
  12.491 +                method.load(iter);
  12.492 +                method.invoke(interfaceCallNoLookup(Iterator.class, "next", Object.class));
  12.493              }
  12.494 -
  12.495 -            final Label testLabel = new Label("test");
  12.496 -
  12.497 -            method._goto(testLabel);
  12.498 -            method.label(loopLabel);
  12.499 -            body.accept(this);
  12.500 -            method.label(continueLabel);
  12.501 -
  12.502 -            if (!body.isTerminal() && modify != null) {
  12.503 -                load(modify);
  12.504 -            }
  12.505 -
  12.506 -            method.label(testLabel);
  12.507 -            if (test != null) {
  12.508 -                new BranchOptimizer(this, method).execute(test, loopLabel, true);
  12.509 -            } else {
  12.510 -                method._goto(loopLabel);
  12.511 -            }
  12.512 -
  12.513 -            method.label(breakLabel);
  12.514 -        }
  12.515 -
  12.516 -        return false;
  12.517 -    }
  12.518 -
  12.519 -    private static int assignSlots(final Block block, final int firstSlot) {
  12.520 -        int nextSlot = firstSlot;
  12.521 -        for (final Symbol symbol : block.getSymbols()) {
  12.522 -            if (symbol.hasSlot()) {
  12.523 -                symbol.setSlot(nextSlot);
  12.524 -                nextSlot += symbol.slotCount();
  12.525 -            }
  12.526 -        }
  12.527 -        return nextSlot;
  12.528 +        }.store();
  12.529 +
  12.530 +        body.accept(this);
  12.531 +
  12.532 +        method.label(forNode.getContinueLabel());
  12.533 +        method.load(iter);
  12.534 +        method.invoke(interfaceCallNoLookup(Iterator.class, "hasNext", boolean.class));
  12.535 +        method.ifne(loopLabel);
  12.536 +        method.label(forNode.getBreakLabel());
  12.537      }
  12.538  
  12.539      /**
  12.540 @@ -967,24 +871,11 @@
  12.541       * @param block block with local vars.
  12.542       */
  12.543      private void initLocals(final Block block) {
  12.544 -        final boolean isFunctionBody = getLexicalContext().isFunctionBody();
  12.545 -
  12.546 -        final int nextFreeSlot;
  12.547 -        if (isFunctionBody) {
  12.548 -            // On entry to function, start with slot 0
  12.549 -            nextFreeSlot = 0;
  12.550 -        } else {
  12.551 -            // Otherwise, continue from previous block's first free slot
  12.552 -            nextFreeSlot = nextFreeSlots[nextFreeSlotsSize - 1];
  12.553 -        }
  12.554 -        if(nextFreeSlotsSize == nextFreeSlots.length) {
  12.555 -            final int[] newNextFreeSlots = new int[nextFreeSlotsSize * 2];
  12.556 -            System.arraycopy(nextFreeSlots, 0, newNextFreeSlots, 0, nextFreeSlotsSize);
  12.557 -            nextFreeSlots = newNextFreeSlots;
  12.558 -        }
  12.559 -        nextFreeSlots[nextFreeSlotsSize++] = assignSlots(block, nextFreeSlot);
  12.560 -
  12.561 -        final FunctionNode function = getLexicalContext().getCurrentFunction();
  12.562 +        lc.nextFreeSlot(block);
  12.563 +
  12.564 +        final boolean isFunctionBody = lc.isFunctionBody();
  12.565 +
  12.566 +        final FunctionNode function = lc.getCurrentFunction();
  12.567          if (isFunctionBody) {
  12.568              /* Fix the predefined slots so they have numbers >= 0, like varargs. */
  12.569              if (function.needsParentScope()) {
  12.570 @@ -1023,7 +914,7 @@
  12.571                  }
  12.572  
  12.573                  if (symbol.isVar()) {
  12.574 -                    if(varsInScope || symbol.isScope()) {
  12.575 +                    if (varsInScope || symbol.isScope()) {
  12.576                          nameList.add(symbol.getName());
  12.577                          newSymbols.add(symbol);
  12.578                          values.add(null);
  12.579 @@ -1062,7 +953,7 @@
  12.580  
  12.581                  @Override
  12.582                  protected void loadScope(MethodEmitter m) {
  12.583 -                    if(function.needsParentScope()) {
  12.584 +                    if (function.needsParentScope()) {
  12.585                          m.loadCompilerConstant(SCOPE);
  12.586                      } else {
  12.587                          m.loadNull();
  12.588 @@ -1096,7 +987,7 @@
  12.589  
  12.590      private void initArguments(final FunctionNode function) {
  12.591          method.loadCompilerConstant(VARARGS);
  12.592 -        if(function.needsCallee()) {
  12.593 +        if (function.needsCallee()) {
  12.594              method.loadCompilerConstant(CALLEE);
  12.595          } else {
  12.596              // If function is strict mode, "arguments.callee" is not populated, so we don't necessarily need the
  12.597 @@ -1126,10 +1017,10 @@
  12.598          LOG.info("=== BEGIN ", functionNode.getName());
  12.599  
  12.600          assert functionNode.getCompileUnit() != null : "no compile unit for " + functionNode.getName() + " " + Debug.id(functionNode);
  12.601 -        push(functionNode.getCompileUnit());
  12.602 -        assert !compileUnits.isEmpty();
  12.603 -
  12.604 -        pushMethodEmitter(unit.getClassEmitter().method(functionNode));
  12.605 +        unit = lc.pushCompileUnit(functionNode.getCompileUnit());
  12.606 +        assert lc.hasCompileUnits();
  12.607 +
  12.608 +        method = lc.pushMethodEmitter(unit.getClassEmitter().method(functionNode));
  12.609          // Mark end for variable tables.
  12.610          method.begin();
  12.611  
  12.612 @@ -1140,11 +1031,11 @@
  12.613      public Node leaveFunctionNode(final FunctionNode functionNode) {
  12.614          try {
  12.615              method.end(); // wrap up this method
  12.616 -            pop(functionNode.getCompileUnit());
  12.617 -            popMethodEmitter(method);
  12.618 +            unit   = lc.popCompileUnit(functionNode.getCompileUnit());
  12.619 +            method = lc.popMethodEmitter(method);
  12.620              LOG.info("=== END ", functionNode.getName());
  12.621  
  12.622 -            final FunctionNode newFunctionNode = functionNode.setState(getLexicalContext(), CompilationState.EMITTED);
  12.623 +            final FunctionNode newFunctionNode = functionNode.setState(lc, CompilationState.EMITTED);
  12.624  
  12.625              newFunctionObject(newFunctionNode, functionNode);
  12.626              return newFunctionNode;
  12.627 @@ -1238,16 +1129,16 @@
  12.628              final MethodEmitter savedMethod = method;
  12.629  
  12.630              for (final ArrayUnit arrayUnit : units) {
  12.631 -                push(arrayUnit.getCompileUnit());
  12.632 +                unit = lc.pushCompileUnit(arrayUnit.getCompileUnit());
  12.633  
  12.634                  final String className = unit.getUnitClassName();
  12.635 -                final String name      = getLexicalContext().getCurrentFunction().uniqueName(SPLIT_PREFIX.symbolName());
  12.636 +                final String name      = lc.getCurrentFunction().uniqueName(SPLIT_PREFIX.symbolName());
  12.637                  final String signature = methodDescriptor(type, Object.class, ScriptFunction.class, ScriptObject.class, type);
  12.638  
  12.639                  final MethodEmitter me = unit.getClassEmitter().method(EnumSet.of(Flag.PUBLIC, Flag.STATIC), name, signature);
  12.640 -                pushMethodEmitter(me);
  12.641 -
  12.642 -                method.setFunctionNode(getLexicalContext().getCurrentFunction());
  12.643 +                method = lc.pushMethodEmitter(me);
  12.644 +
  12.645 +                method.setFunctionNode(lc.getCurrentFunction());
  12.646                  method.begin();
  12.647  
  12.648                  fixScopeSlot();
  12.649 @@ -1260,7 +1151,7 @@
  12.650  
  12.651                  method._return();
  12.652                  method.end();
  12.653 -                popMethodEmitter(me);
  12.654 +                method = lc.popMethodEmitter(me);
  12.655  
  12.656                  assert method == savedMethod;
  12.657                  method.loadCompilerConstant(THIS);
  12.658 @@ -1271,7 +1162,7 @@
  12.659                  method.swap();
  12.660                  method.invokestatic(className, name, signature);
  12.661  
  12.662 -                pop(unit);
  12.663 +                unit = lc.popCompileUnit(unit);
  12.664              }
  12.665  
  12.666              return method;
  12.667 @@ -1407,7 +1298,7 @@
  12.668              return loadRegexToken(regexToken);
  12.669          }
  12.670          // emit field
  12.671 -        final String       regexName    = getLexicalContext().getCurrentFunction().uniqueName(REGEX_PREFIX.symbolName());
  12.672 +        final String       regexName    = lc.getCurrentFunction().uniqueName(REGEX_PREFIX.symbolName());
  12.673          final ClassEmitter classEmitter = unit.getClassEmitter();
  12.674  
  12.675          classEmitter.field(EnumSet.of(PRIVATE, STATIC), regexName, Object.class);
  12.676 @@ -1545,7 +1436,7 @@
  12.677  
  12.678          method.registerReturn();
  12.679  
  12.680 -        final Type returnType = getLexicalContext().getCurrentFunction().getReturnType();
  12.681 +        final Type returnType = lc.getCurrentFunction().getReturnType();
  12.682  
  12.683          final Node expression = returnNode.getExpression();
  12.684          if (expression != null) {
  12.685 @@ -1756,7 +1647,7 @@
  12.686  
  12.687          final CompileUnit splitCompileUnit = splitNode.getCompileUnit();
  12.688  
  12.689 -        final FunctionNode fn   = getLexicalContext().getCurrentFunction();
  12.690 +        final FunctionNode fn   = lc.getCurrentFunction();
  12.691          final String className  = splitCompileUnit.getUnitClassName();
  12.692          final String name       = splitNode.getName();
  12.693  
  12.694 @@ -1767,7 +1658,7 @@
  12.695                  new Class<?>[] {ScriptFunction.class, Object.class, ScriptObject.class};
  12.696  
  12.697          final MethodEmitter caller = method;
  12.698 -        push(splitCompileUnit);
  12.699 +        unit = lc.pushCompileUnit(splitCompileUnit);
  12.700  
  12.701          final Call splitCall = staticCallNoLookup(
  12.702              className,
  12.703 @@ -1781,8 +1672,7 @@
  12.704                          rtype,
  12.705                          ptypes);
  12.706  
  12.707 -        pushMethodEmitter(splitEmitter);
  12.708 -
  12.709 +        method = lc.pushMethodEmitter(splitEmitter);
  12.710          method.setFunctionNode(fn);
  12.711  
  12.712          if (fn.needsCallee()) {
  12.713 @@ -1809,7 +1699,7 @@
  12.714      }
  12.715  
  12.716      private void fixScopeSlot() {
  12.717 -        if (getLexicalContext().getCurrentFunction().compilerConstant(SCOPE).getSlot() != SCOPE.slot()) {
  12.718 +        if (lc.getCurrentFunction().compilerConstant(SCOPE).getSlot() != SCOPE.slot()) {
  12.719              // TODO hack to move the scope to the expected slot (that's needed because split methods reuse the same slots as the root method)
  12.720              method.load(Type.typeFor(ScriptObject.class), SCOPE.slot());
  12.721              method.storeCompilerConstant(SCOPE);
  12.722 @@ -1826,15 +1716,15 @@
  12.723              // Wrap up this method.
  12.724  
  12.725              method.loadCompilerConstant(RETURN);
  12.726 -            method._return(getLexicalContext().getCurrentFunction().getReturnType());
  12.727 +            method._return(lc.getCurrentFunction().getReturnType());
  12.728              method.end();
  12.729  
  12.730 -            pop(splitNode.getCompileUnit());
  12.731 -            popMethodEmitter(method);
  12.732 +            unit   = lc.popCompileUnit(splitNode.getCompileUnit());
  12.733 +            method = lc.popMethodEmitter(method);
  12.734  
  12.735          } catch (final Throwable t) {
  12.736              Context.printStackTrace(t);
  12.737 -            final VerifyError e = new VerifyError("Code generation bug in \"" + splitNode.getName() + "\": likely stack misaligned: " + t + " " + getLexicalContext().getCurrentFunction().getSource().getName());
  12.738 +            final VerifyError e = new VerifyError("Code generation bug in \"" + splitNode.getName() + "\": likely stack misaligned: " + t + " " + lc.getCurrentFunction().getSource().getName());
  12.739              e.initCause(t);
  12.740              throw e;
  12.741          }
  12.742 @@ -1862,7 +1752,7 @@
  12.743              //has to be zero
  12.744              caller.label(new Label("split_return"));
  12.745              method.loadCompilerConstant(RETURN);
  12.746 -            caller._return(getLexicalContext().getCurrentFunction().getReturnType());
  12.747 +            caller._return(lc.getCurrentFunction().getReturnType());
  12.748              caller.label(breakLabel);
  12.749          } else {
  12.750              assert !targets.isEmpty();
  12.751 @@ -1879,14 +1769,14 @@
  12.752                  caller.label(labels[i - low]);
  12.753                  if (i == 0) {
  12.754                      caller.loadCompilerConstant(RETURN);
  12.755 -                    caller._return(getLexicalContext().getCurrentFunction().getReturnType());
  12.756 +                    caller._return(lc.getCurrentFunction().getReturnType());
  12.757                  } else {
  12.758                      // Clear split state.
  12.759                      caller.loadCompilerConstant(SCOPE);
  12.760                      caller.checkcast(Scope.class);
  12.761                      caller.load(-1);
  12.762                      caller.invoke(Scope.SET_SPLIT_STATE);
  12.763 -                    caller.splitAwareGoto(getLexicalContext(), targets.get(i - 1));
  12.764 +                    caller.splitAwareGoto(lc, targets.get(i - 1));
  12.765                  }
  12.766              }
  12.767              caller.label(breakLabel);
  12.768 @@ -2028,9 +1918,16 @@
  12.769      public boolean enterThrowNode(final ThrowNode throwNode) {
  12.770          lineNumber(throwNode);
  12.771  
  12.772 +        if (throwNode.isSyntheticRethrow()) {
  12.773 +            //do not wrap whatever this is in an ecma exception, just rethrow it
  12.774 +            load(throwNode.getExpression());
  12.775 +            method.athrow();
  12.776 +            return false;
  12.777 +        }
  12.778 +
  12.779          method._new(ECMAException.class).dup();
  12.780  
  12.781 -        final Source source     = getLexicalContext().getCurrentFunction().getSource();
  12.782 +        final Source source     = lc.getCurrentFunction().getSource();
  12.783  
  12.784          final Node   expression = throwNode.getExpression();
  12.785          final int    position   = throwNode.position();
  12.786 @@ -2081,7 +1978,7 @@
  12.787              //TODO this is very ugly - try not to call enter/leave methods directly
  12.788              //better to use the implicit lexical context scoping given by the visitor's
  12.789              //accept method.
  12.790 -            getLexicalContext().push(catchBlock);
  12.791 +            lc.push(catchBlock);
  12.792              enterBlock(catchBlock);
  12.793  
  12.794              final CatchNode catchNode          = (CatchNode)catchBlocks.get(i).getStatements().get(0);
  12.795 @@ -2094,15 +1991,19 @@
  12.796                  protected void storeNonDiscard() {
  12.797                      return;
  12.798                  }
  12.799 +
  12.800                  @Override
  12.801                  protected void evaluate() {
  12.802 +                    if (catchNode.isSyntheticRethrow()) {
  12.803 +                        method.load(symbol);
  12.804 +                        return;
  12.805 +                    }
  12.806                      /*
  12.807                       * If caught object is an instance of ECMAException, then
  12.808                       * bind obj.thrown to the script catch var. Or else bind the
  12.809                       * caught object itself to the script catch var.
  12.810                       */
  12.811                      final Label notEcmaException = new Label("no_ecma_exception");
  12.812 -
  12.813                      method.load(symbol).dup()._instanceof(ECMAException.class).ifeq(notEcmaException);
  12.814                      method.checkcast(ECMAException.class); //TODO is this necessary?
  12.815                      method.getField(ECMAException.THROWN);
  12.816 @@ -2137,7 +2038,7 @@
  12.817              }
  12.818  
  12.819              leaveBlock(catchBlock);
  12.820 -            getLexicalContext().pop(catchBlock);
  12.821 +            lc.pop(catchBlock);
  12.822          }
  12.823  
  12.824          method.label(skip);
  12.825 @@ -2234,7 +2135,7 @@
  12.826          final boolean hasScope = method.hasScope();
  12.827  
  12.828          final Label tryLabel;
  12.829 -        if(hasScope) {
  12.830 +        if (hasScope) {
  12.831              tryLabel = new Label("with_try");
  12.832              method.label(tryLabel);
  12.833              method.loadCompilerConstant(SCOPE);
  12.834 @@ -2245,7 +2146,7 @@
  12.835          load(expression);
  12.836          assert expression.getType().isObject() : "with expression needs to be object: " + expression;
  12.837  
  12.838 -        if(hasScope) {
  12.839 +        if (hasScope) {
  12.840              // Construct a WithObject if we have a scope
  12.841              method.invoke(ScriptRuntime.OPEN_WITH);
  12.842              method.storeCompilerConstant(SCOPE);
  12.843 @@ -2285,7 +2186,7 @@
  12.844      @Override
  12.845      public boolean enterADD(final UnaryNode unaryNode) {
  12.846          load(unaryNode.rhs());
  12.847 -        assert unaryNode.rhs().getType().isNumber();
  12.848 +        assert unaryNode.rhs().getType().isNumber() : unaryNode.rhs().getType() + " "+ unaryNode.getSymbol();
  12.849          method.store(unaryNode.getSymbol());
  12.850  
  12.851          return false;
  12.852 @@ -2320,7 +2221,7 @@
  12.853                  }
  12.854                  method.convert(Type.OBJECT);
  12.855              } else if (value instanceof Boolean) {
  12.856 -                method.getField(staticField(Boolean.class, value.toString().toUpperCase(), Boolean.class));
  12.857 +                method.getField(staticField(Boolean.class, value.toString().toUpperCase(Locale.ENGLISH), Boolean.class));
  12.858              } else {
  12.859                  load(rhs);
  12.860                  method.convert(unaryNode.getType());
  12.861 @@ -2387,13 +2288,13 @@
  12.862      public boolean enterDISCARD(final UnaryNode unaryNode) {
  12.863          final Node rhs = unaryNode.rhs();
  12.864  
  12.865 -        discard.push(rhs);
  12.866 +        lc.pushDiscard(rhs);
  12.867          load(rhs);
  12.868  
  12.869 -        if (discard.peek() == rhs) {
  12.870 +        if (lc.getCurrentDiscard() == rhs) {
  12.871              assert !rhs.isAssignment();
  12.872              method.pop();
  12.873 -            discard.pop();
  12.874 +            lc.popDiscard();
  12.875          }
  12.876  
  12.877          return false;
  12.878 @@ -2445,7 +2346,7 @@
  12.879          assert lhs.getType().equals(rhs.getType()) && lhs.getType().equals(type) : lhs.getType() + " != " + rhs.getType() + " != " + type + " " + new ASTWriter(lhs) + " " + new ASTWriter(rhs);
  12.880          load(lhs);
  12.881          load(rhs);
  12.882 -        method.add();
  12.883 +        method.add(); //if the symbol is optimistic, it always needs to be written, not on the stack?
  12.884          method.store(symbol);
  12.885          return null;
  12.886      }
  12.887 @@ -2989,53 +2890,12 @@
  12.888       * Generate all shared scope calls generated during codegen.
  12.889       */
  12.890      protected void generateScopeCalls() {
  12.891 -        for (final SharedScopeCall scopeAccess : scopeCalls.values()) {
  12.892 +        for (final SharedScopeCall scopeAccess : lc.getScopeCalls()) {
  12.893              scopeAccess.generateScopeCall();
  12.894          }
  12.895      }
  12.896  
  12.897      /**
  12.898 -     * Get a shared static method representing a dynamic scope callsite.
  12.899 -     *
  12.900 -     * @param symbol the symbol
  12.901 -     * @param valueType the value type of the symbol
  12.902 -     * @param returnType the return type
  12.903 -     * @param paramTypes the parameter types
  12.904 -     * @param flags the callsite flags
  12.905 -     * @return an object representing a shared scope call
  12.906 -     */
  12.907 -    private SharedScopeCall getScopeCall(final Symbol symbol, final Type valueType, final Type returnType,
  12.908 -                                         final Type[] paramTypes, final int flags) {
  12.909 -
  12.910 -        final SharedScopeCall scopeCall = new SharedScopeCall(symbol, valueType, returnType, paramTypes, flags);
  12.911 -        if (scopeCalls.containsKey(scopeCall)) {
  12.912 -            return scopeCalls.get(scopeCall);
  12.913 -        }
  12.914 -        scopeCall.setClassAndName(unit, getLexicalContext().getCurrentFunction().uniqueName("scopeCall"));
  12.915 -        scopeCalls.put(scopeCall, scopeCall);
  12.916 -        return scopeCall;
  12.917 -    }
  12.918 -
  12.919 -    /**
  12.920 -     * Get a shared static method representing a dynamic scope get access.
  12.921 -     *
  12.922 -     * @param type the type of the variable
  12.923 -     * @param symbol the symbol
  12.924 -     * @param flags the callsite flags
  12.925 -     * @return an object representing a shared scope call
  12.926 -     */
  12.927 -    private SharedScopeCall getScopeGet(final Type type, final Symbol symbol, final int flags) {
  12.928 -
  12.929 -        final SharedScopeCall scopeCall = new SharedScopeCall(symbol, type, type, null, flags);
  12.930 -        if (scopeCalls.containsKey(scopeCall)) {
  12.931 -            return scopeCalls.get(scopeCall);
  12.932 -        }
  12.933 -        scopeCall.setClassAndName(unit, getLexicalContext().getCurrentFunction().uniqueName("scopeCall"));
  12.934 -        scopeCalls.put(scopeCall, scopeCall);
  12.935 -        return scopeCall;
  12.936 -    }
  12.937 -
  12.938 -    /**
  12.939       * Debug code used to print symbols
  12.940       *
  12.941       * @param block the block we are in
  12.942 @@ -3129,14 +2989,14 @@
  12.943  
  12.944          private void prologue() {
  12.945              final Symbol targetSymbol = target.getSymbol();
  12.946 -            final Symbol scopeSymbol  = getLexicalContext().getCurrentFunction().compilerConstant(SCOPE);
  12.947 +            final Symbol scopeSymbol  = lc.getCurrentFunction().compilerConstant(SCOPE);
  12.948  
  12.949              /**
  12.950               * This loads the parts of the target, e.g base and index. they are kept
  12.951               * on the stack throughout the store and used at the end to execute it
  12.952               */
  12.953  
  12.954 -            target.accept(new NodeVisitor() {
  12.955 +            target.accept(new NodeVisitor<LexicalContext>(new LexicalContext()) {
  12.956                  @Override
  12.957                  public boolean enterIdentNode(final IdentNode node) {
  12.958                      if (targetSymbol.isScope()) {
  12.959 @@ -3203,22 +3063,21 @@
  12.960           * @return the quick symbol
  12.961           */
  12.962          private Symbol quickSymbol(final Type type, final String prefix) {
  12.963 -            final String name = getLexicalContext().getCurrentFunction().uniqueName(prefix);
  12.964 +            final String name = lc.getCurrentFunction().uniqueName(prefix);
  12.965              final Symbol symbol = new Symbol(name, IS_TEMP | IS_INTERNAL);
  12.966  
  12.967              symbol.setType(type);
  12.968 -            final int quickSlot = nextFreeSlots[nextFreeSlotsSize - 1];
  12.969 -            nextFreeSlots[nextFreeSlotsSize - 1] = quickSlot + symbol.slotCount();
  12.970 -            symbol.setSlot(quickSlot);
  12.971 +
  12.972 +            symbol.setSlot(lc.quickSlot(symbol));
  12.973  
  12.974              return symbol;
  12.975          }
  12.976  
  12.977          // store the result that "lives on" after the op, e.g. "i" in i++ postfix.
  12.978          protected void storeNonDiscard() {
  12.979 -            if (discard.peek() == assignNode) {
  12.980 +            if (lc.getCurrentDiscard() == assignNode) {
  12.981                  assert assignNode.isAssignment();
  12.982 -                discard.pop();
  12.983 +                lc.popDiscard();
  12.984                  return;
  12.985              }
  12.986  
  12.987 @@ -3246,7 +3105,7 @@
  12.988               */
  12.989              method.convert(target.getType());
  12.990  
  12.991 -            target.accept(new NodeVisitor() {
  12.992 +            target.accept(new NodeVisitor<LexicalContext>(new LexicalContext()) {
  12.993                  @Override
  12.994                  protected boolean enterDefault(Node node) {
  12.995                      throw new AssertionError("Unexpected node " + node + " in store epilogue");
  12.996 @@ -3308,7 +3167,6 @@
  12.997      }
  12.998  
  12.999      private void newFunctionObject(final FunctionNode functionNode, final FunctionNode originalFunctionNode) {
 12.1000 -        final LexicalContext lc = getLexicalContext();
 12.1001          assert lc.peek() == functionNode;
 12.1002          // We don't emit a ScriptFunction on stack for:
 12.1003          // 1. the outermost compiled function (as there's no code being generated in its outer context that'd need it

    13.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    13.2 +++ b/src/jdk/nashorn/internal/codegen/CodeGeneratorLexicalContext.java	Mon Jun 03 23:24:36 2013 -0700
    13.3 @@ -0,0 +1,235 @@
    13.4 +/*
    13.5 + * Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.
    13.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    13.7 + *
    13.8 + * This code is free software; you can redistribute it and/or modify it
    13.9 + * under the terms of the GNU General Public License version 2 only, as
   13.10 + * published by the Free Software Foundation.  Oracle designates this
   13.11 + * particular file as subject to the "Classpath" exception as provided
   13.12 + * by Oracle in the LICENSE file that accompanied this code.
   13.13 + *
   13.14 + * This code is distributed in the hope that it will be useful, but WITHOUT
   13.15 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   13.16 + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   13.17 + * version 2 for more details (a copy is included in the LICENSE file that
   13.18 + * accompanied this code).
   13.19 + *
   13.20 + * You should have received a copy of the GNU General Public License version
   13.21 + * 2 along with this work; if not, write to the Free Software Foundation,
   13.22 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   13.23 + *
   13.24 + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
   13.25 + * or visit www.oracle.com if you need additional information or have any
   13.26 + * questions.
   13.27 + */
   13.28 +
   13.29 +package jdk.nashorn.internal.codegen;
   13.30 +
   13.31 +import java.util.ArrayDeque;
   13.32 +import java.util.Collection;
   13.33 +import java.util.Collections;
   13.34 +import java.util.Deque;
   13.35 +import java.util.HashMap;
   13.36 +import java.util.Map;
   13.37 +
   13.38 +import jdk.nashorn.internal.codegen.types.Type;
   13.39 +import jdk.nashorn.internal.ir.Block;
   13.40 +import jdk.nashorn.internal.ir.FunctionNode;
   13.41 +import jdk.nashorn.internal.ir.LexicalContext;
   13.42 +import jdk.nashorn.internal.ir.LexicalContextNode;
   13.43 +import jdk.nashorn.internal.ir.Node;
   13.44 +import jdk.nashorn.internal.ir.Symbol;
   13.45 +import jdk.nashorn.internal.ir.WithNode;
   13.46 +
   13.47 +/**
   13.48 + * A lexical context that also tracks if we have any dynamic scopes in the context. Such scopes can have new
   13.49 + * variables introduced into them at run time - a with block or a function directly containing an eval call.
   13.50 + * Furthermore, this class keeps track of current discard state, which the current method emitter being used is,
   13.51 + * the current compile unit, and local variable indexes
   13.52 + */
   13.53 +final class CodeGeneratorLexicalContext extends LexicalContext {
   13.54 +    private int dynamicScopeCount;
   13.55 +
   13.56 +    /** Map of shared scope call sites */
   13.57 +    private final Map<SharedScopeCall, SharedScopeCall> scopeCalls = new HashMap<>();
   13.58 +
   13.59 +    /** Compile unit stack - every time we start a sub method (e.g. a split) we push one */
   13.60 +    private final Deque<CompileUnit> compileUnits = new ArrayDeque<>();
   13.61 +
   13.62 +    /** Method emitter stack - every time we start a sub method (e.g. a split) we push one */
   13.63 +    private final Deque<MethodEmitter> methodEmitters = new ArrayDeque<>();
   13.64 +
   13.65 +    /** The discard stack - whenever we enter a discard node we keep track of its return value status -
   13.66 +     *  i.e. should we keep it or throw it away */
   13.67 +    private final Deque<Node> discard = new ArrayDeque<>();
   13.68 +
   13.69 +    /** A stack tracking the next free local variable slot in the blocks. There's one entry for every block
   13.70 +     *  currently on the lexical context stack. */
   13.71 +    private int[] nextFreeSlots = new int[16];
   13.72 +
   13.73 +    /** size of next free slot vector */
   13.74 +    private int nextFreeSlotsSize;
   13.75 +
   13.76 +    @Override
   13.77 +    public <T extends LexicalContextNode> T push(final T node) {
   13.78 +        if (isDynamicScopeBoundary(node)) {
   13.79 +            ++dynamicScopeCount;
   13.80 +        }
   13.81 +        return super.push(node);
   13.82 +    }
   13.83 +
   13.84 +    @Override
   13.85 +    public <T extends LexicalContextNode> T pop(final T node) {
   13.86 +        final T popped = super.pop(node);
   13.87 +        if (isDynamicScopeBoundary(popped)) {
   13.88 +            --dynamicScopeCount;
   13.89 +        }
   13.90 +        if (node instanceof Block) {
   13.91 +            --nextFreeSlotsSize;
   13.92 +        }
   13.93 +        return popped;
   13.94 +    }
   13.95 +
   13.96 +    private boolean isDynamicScopeBoundary(final LexicalContextNode node) {
   13.97 +        if (node instanceof Block) {
   13.98 +            // Block's immediate parent is a with node. Note we aren't testing for a WithNode, as that'd capture
   13.99 +            // processing of WithNode.expression too, but it should be unaffected.
  13.100 +            return !isEmpty() && peek() instanceof WithNode;
  13.101 +        } else if (node instanceof FunctionNode) {
  13.102 +            // Function has a direct eval in it (so a top-level "var ..." in the eval code can introduce a new
  13.103 +            // variable into the function's scope), and it isn't strict (as evals in strict functions get an
  13.104 +            // isolated scope).
  13.105 +            return isFunctionDynamicScope((FunctionNode)node);
  13.106 +        }
  13.107 +        return false;
  13.108 +    }
  13.109 +
  13.110 +    boolean inDynamicScope() {
  13.111 +        return dynamicScopeCount > 0;
  13.112 +    }
  13.113 +
  13.114 +    static boolean isFunctionDynamicScope(FunctionNode fn) {
  13.115 +        return fn.hasEval() && !fn.isStrict();
  13.116 +    }
  13.117 +
  13.118 +    MethodEmitter pushMethodEmitter(final MethodEmitter newMethod) {
  13.119 +        methodEmitters.push(newMethod);
  13.120 +        return newMethod;
  13.121 +    }
  13.122 +
  13.123 +    MethodEmitter popMethodEmitter(final MethodEmitter oldMethod) {
  13.124 +        assert methodEmitters.peek() == oldMethod;
  13.125 +        methodEmitters.pop();
  13.126 +        return methodEmitters.isEmpty() ? null : methodEmitters.peek();
  13.127 +    }
  13.128 +
  13.129 +    CompileUnit pushCompileUnit(final CompileUnit newUnit) {
  13.130 +        compileUnits.push(newUnit);
  13.131 +        return newUnit;
  13.132 +    }
  13.133 +
  13.134 +    CompileUnit popCompileUnit(final CompileUnit oldUnit) {
  13.135 +        assert compileUnits.peek() == oldUnit;
  13.136 +        compileUnits.pop();
  13.137 +        return compileUnits.isEmpty() ? null : compileUnits.peek();
  13.138 +    }
  13.139 +
  13.140 +    boolean hasCompileUnits() {
  13.141 +        return !compileUnits.isEmpty();
  13.142 +    }
  13.143 +
  13.144 +    Collection<SharedScopeCall> getScopeCalls() {
  13.145 +        return Collections.unmodifiableCollection(scopeCalls.values());
  13.146 +    }
  13.147 +
  13.148 +    /**
  13.149 +     * Get a shared static method representing a dynamic scope callsite.
  13.150 +     *
  13.151 +     * @param unit current compile unit
  13.152 +     * @param symbol the symbol
  13.153 +     * @param valueType the value type of the symbol
  13.154 +     * @param returnType the return type
  13.155 +     * @param paramTypes the parameter types
  13.156 +     * @param flags the callsite flags
  13.157 +     * @return an object representing a shared scope call
  13.158 +     */
  13.159 +    SharedScopeCall getScopeCall(final CompileUnit unit, final Symbol symbol, final Type valueType, final Type returnType, final Type[] paramTypes, final int flags) {
  13.160 +        final SharedScopeCall scopeCall = new SharedScopeCall(symbol, valueType, returnType, paramTypes, flags);
  13.161 +        if (scopeCalls.containsKey(scopeCall)) {
  13.162 +            return scopeCalls.get(scopeCall);
  13.163 +        }
  13.164 +        scopeCall.setClassAndName(unit, getCurrentFunction().uniqueName("scopeCall"));
  13.165 +        scopeCalls.put(scopeCall, scopeCall);
  13.166 +        return scopeCall;
  13.167 +    }
  13.168 +
  13.169 +    /**
  13.170 +     * Get a shared static method representing a dynamic scope get access.
  13.171 +     *
  13.172 +     * @param unit current compile unit
  13.173 +     * @param type the type of the variable
  13.174 +     * @param symbol the symbol
  13.175 +     * @param flags the callsite flags
  13.176 +     * @return an object representing a shared scope call
  13.177 +     */
  13.178 +    SharedScopeCall getScopeGet(final CompileUnit unit, final Type type, final Symbol symbol, final int flags) {
  13.179 +        final SharedScopeCall scopeCall = new SharedScopeCall(symbol, type, type, null, flags);
  13.180 +        if (scopeCalls.containsKey(scopeCall)) {
  13.181 +            return scopeCalls.get(scopeCall);
  13.182 +        }
  13.183 +        scopeCall.setClassAndName(unit, getCurrentFunction().uniqueName("scopeCall"));
  13.184 +        scopeCalls.put(scopeCall, scopeCall);
  13.185 +        return scopeCall;
  13.186 +    }
  13.187 +
  13.188 +
  13.189 +    void nextFreeSlot(final Block block) {
  13.190 +        final boolean isFunctionBody = isFunctionBody();
  13.191 +
  13.192 +        final int nextFreeSlot;
  13.193 +        if (isFunctionBody) {
  13.194 +            // On entry to function, start with slot 0
  13.195 +            nextFreeSlot = 0;
  13.196 +        } else {
  13.197 +            // Otherwise, continue from previous block's first free slot
  13.198 +            nextFreeSlot = nextFreeSlots[nextFreeSlotsSize - 1];
  13.199 +        }
  13.200 +        if (nextFreeSlotsSize == nextFreeSlots.length) {
  13.201 +            final int[] newNextFreeSlots = new int[nextFreeSlotsSize * 2];
  13.202 +            System.arraycopy(nextFreeSlots, 0, newNextFreeSlots, 0, nextFreeSlotsSize);
  13.203 +            nextFreeSlots = newNextFreeSlots;
  13.204 +        }
  13.205 +        nextFreeSlots[nextFreeSlotsSize++] = assignSlots(block, nextFreeSlot);
  13.206 +    }
  13.207 +
  13.208 +    private static int assignSlots(final Block block, final int firstSlot) {
  13.209 +        int nextSlot = firstSlot;
  13.210 +        for (final Symbol symbol : block.getSymbols()) {
  13.211 +            if (symbol.hasSlot()) {
  13.212 +                symbol.setSlot(nextSlot);
  13.213 +                nextSlot += symbol.slotCount();
  13.214 +            }
  13.215 +        }
  13.216 +        return nextSlot;
  13.217 +    }
  13.218 +
  13.219 +    void pushDiscard(final Node node) {
  13.220 +        discard.push(node);
  13.221 +    }
  13.222 +
  13.223 +    Node popDiscard() {
  13.224 +        return discard.pop();
  13.225 +    }
  13.226 +
  13.227 +    Node getCurrentDiscard() {
  13.228 +        return discard.peek();
  13.229 +    }
  13.230 +
  13.231 +    int quickSlot(final Symbol symbol) {
  13.232 +        final int quickSlot = nextFreeSlots[nextFreeSlotsSize - 1];
  13.233 +        nextFreeSlots[nextFreeSlotsSize - 1] = quickSlot + symbol.slotCount();
  13.234 +        return quickSlot;
  13.235 +    }
  13.236 +
  13.237 +}
  13.238 +

    14.1 --- a/src/jdk/nashorn/internal/codegen/CompilationPhase.java	Thu May 30 10:58:35 2013 -0700
    14.2 +++ b/src/jdk/nashorn/internal/codegen/CompilationPhase.java	Mon Jun 03 23:24:36 2013 -0700
    14.3 @@ -11,20 +11,27 @@
    14.4  import java.io.File;
    14.5  import java.io.FileOutputStream;
    14.6  import java.io.IOException;
    14.7 +import java.util.ArrayDeque;
    14.8 +import java.util.ArrayList;
    14.9 +import java.util.Deque;
   14.10  import java.util.EnumSet;
   14.11  import java.util.HashSet;
   14.12 +import java.util.List;
   14.13  import java.util.Set;
   14.14 +
   14.15 +import jdk.nashorn.internal.codegen.types.Range;
   14.16  import jdk.nashorn.internal.codegen.types.Type;
   14.17  import jdk.nashorn.internal.ir.Block;
   14.18  import jdk.nashorn.internal.ir.CallNode;
   14.19  import jdk.nashorn.internal.ir.FunctionNode;
   14.20 +import jdk.nashorn.internal.ir.LexicalContext;
   14.21 +import jdk.nashorn.internal.ir.ReturnNode;
   14.22 +import jdk.nashorn.internal.ir.Symbol;
   14.23  import jdk.nashorn.internal.ir.FunctionNode.CompilationState;
   14.24 -import jdk.nashorn.internal.ir.LexicalContext;
   14.25  import jdk.nashorn.internal.ir.Node;
   14.26  import jdk.nashorn.internal.ir.TemporarySymbols;
   14.27  import jdk.nashorn.internal.ir.debug.ASTWriter;
   14.28  import jdk.nashorn.internal.ir.debug.PrintVisitor;
   14.29 -import jdk.nashorn.internal.ir.visitor.NodeOperatorVisitor;
   14.30  import jdk.nashorn.internal.ir.visitor.NodeVisitor;
   14.31  import jdk.nashorn.internal.runtime.ECMAErrors;
   14.32  import jdk.nashorn.internal.runtime.ScriptEnvironment;
   14.33 @@ -66,7 +73,7 @@
   14.34  
   14.35              FunctionNode newFunctionNode = outermostFunctionNode;
   14.36  
   14.37 -            newFunctionNode = (FunctionNode)newFunctionNode.accept(new NodeVisitor() {
   14.38 +            newFunctionNode = (FunctionNode)newFunctionNode.accept(new NodeVisitor<LexicalContext>(new LexicalContext()) {
   14.39                  // self references are done with invokestatic and thus cannot
   14.40                  // have trampolines - never lazy
   14.41                  @Override
   14.42 @@ -99,10 +106,9 @@
   14.43                  lazy.remove(node);
   14.44              }
   14.45  
   14.46 -            newFunctionNode = (FunctionNode)newFunctionNode.accept(new NodeOperatorVisitor() {
   14.47 +            newFunctionNode = (FunctionNode)newFunctionNode.accept(new NodeVisitor<LexicalContext>(new LexicalContext()) {
   14.48                  @Override
   14.49                  public Node leaveFunctionNode(final FunctionNode functionNode) {
   14.50 -                    final LexicalContext lc = getLexicalContext();
   14.51                      if (lazy.contains(functionNode)) {
   14.52                          Compiler.LOG.fine(
   14.53                                  "Marking ",
   14.54 @@ -174,7 +180,7 @@
   14.55          FunctionNode transform(final Compiler compiler, final FunctionNode fn) {
   14.56              final TemporarySymbols ts = compiler.getTemporarySymbols();
   14.57              final FunctionNode newFunctionNode = (FunctionNode)enterAttr(fn, ts).accept(new Attr(ts));
   14.58 -            if(compiler.getEnv()._print_mem_usage) {
   14.59 +            if (compiler.getEnv()._print_mem_usage) {
   14.60                  Compiler.LOG.info("Attr temporary symbol count: " + ts.getTotalSymbolCount());
   14.61              }
   14.62              return newFunctionNode;
   14.63 @@ -186,12 +192,11 @@
   14.64           * @param functionNode node where to start iterating
   14.65           */
   14.66          private FunctionNode enterAttr(final FunctionNode functionNode, final TemporarySymbols ts) {
   14.67 -            return (FunctionNode)functionNode.accept(new NodeVisitor() {
   14.68 +            return (FunctionNode)functionNode.accept(new NodeVisitor<LexicalContext>(new LexicalContext()) {
   14.69                  @Override
   14.70                  public Node leaveFunctionNode(final FunctionNode node) {
   14.71 -                    final LexicalContext lc = getLexicalContext();
   14.72                      if (node.isLazy()) {
   14.73 -                        FunctionNode newNode = node.setReturnType(getLexicalContext(), Type.OBJECT);
   14.74 +                        FunctionNode newNode = node.setReturnType(lc, Type.OBJECT);
   14.75                          return ts.ensureSymbol(lc, Type.OBJECT, newNode);
   14.76                      }
   14.77                      //node may have a reference here that needs to be nulled if it was referred to by
   14.78 @@ -208,6 +213,89 @@
   14.79      },
   14.80  
   14.81      /*
   14.82 +     * Range analysis
   14.83 +     *    Conservatively prove that certain variables can be narrower than
   14.84 +     *    the most generic number type
   14.85 +     */
   14.86 +    RANGE_ANALYSIS_PHASE(EnumSet.of(INITIALIZED, PARSED, CONSTANT_FOLDED, LOWERED, ATTR)) {
   14.87 +        @Override
   14.88 +        FunctionNode transform(final Compiler compiler, final FunctionNode fn) {
   14.89 +            if (!compiler.getEnv()._range_analysis) {
   14.90 +                return fn;
   14.91 +            }
   14.92 +
   14.93 +            FunctionNode newFunctionNode = (FunctionNode)fn.accept(new RangeAnalyzer());
   14.94 +            final List<ReturnNode> returns = new ArrayList<>();
   14.95 +
   14.96 +            newFunctionNode = (FunctionNode)newFunctionNode.accept(new NodeVisitor<LexicalContext>(new LexicalContext()) {
   14.97 +                private final Deque<ArrayList<ReturnNode>> returnStack = new ArrayDeque<>();
   14.98 +
   14.99 +                @Override
  14.100 +                public boolean enterFunctionNode(final FunctionNode functionNode) {
  14.101 +                    returnStack.push(new ArrayList<ReturnNode>());
  14.102 +                    return true;
  14.103 +                }
  14.104 +
  14.105 +                @Override
  14.106 +                public Node leaveFunctionNode(final FunctionNode functionNode) {
  14.107 +                    Type returnType = Type.UNKNOWN;
  14.108 +                    for (final ReturnNode ret : returnStack.pop()) {
  14.109 +                        if (ret.getExpression() == null) {
  14.110 +                            returnType = Type.OBJECT;
  14.111 +                            break;
  14.112 +                        }
  14.113 +                        returnType = Type.widest(returnType, ret.getExpression().getType());
  14.114 +                    }
  14.115 +                    return functionNode.setReturnType(lc, returnType);
  14.116 +                }
  14.117 +
  14.118 +                @Override
  14.119 +                public Node leaveReturnNode(final ReturnNode returnNode) {
  14.120 +                    final ReturnNode result = (ReturnNode)leaveDefault(returnNode);
  14.121 +                    returns.add(result);
  14.122 +                    return result;
  14.123 +                }
  14.124 +
  14.125 +                @Override
  14.126 +                public Node leaveDefault(final Node node) {
  14.127 +                    final Symbol symbol = node.getSymbol();
  14.128 +                    if (symbol != null) {
  14.129 +                        final Range range  = symbol.getRange();
  14.130 +                        final Type  symbolType = symbol.getSymbolType();
  14.131 +                        if (!symbolType.isNumeric()) {
  14.132 +                            return node;
  14.133 +                        }
  14.134 +                        final Type  rangeType  = range.getType();
  14.135 +                        if (!Type.areEquivalent(symbolType, rangeType) && Type.widest(symbolType, rangeType) == symbolType) { //we can narrow range
  14.136 +                            RangeAnalyzer.LOG.info("[", lc.getCurrentFunction().getName(), "] ", symbol, " can be ", range.getType(), " ", symbol.getRange());
  14.137 +                            return node.setSymbol(lc, symbol.setTypeOverrideShared(range.getType(), compiler.getTemporarySymbols()));
  14.138 +                        }
  14.139 +                    }
  14.140 +                    return node;
  14.141 +                }
  14.142 +            });
  14.143 +
  14.144 +            Type returnType = Type.UNKNOWN;
  14.145 +            for (final ReturnNode node : returns) {
  14.146 +                if (node.getExpression() != null) {
  14.147 +                    returnType = Type.widest(returnType, node.getExpression().getType());
  14.148 +                } else {
  14.149 +                    returnType = Type.OBJECT;
  14.150 +                    break;
  14.151 +                }
  14.152 +            }
  14.153 +
  14.154 +            return newFunctionNode.setReturnType(null, returnType);
  14.155 +        }
  14.156 +
  14.157 +        @Override
  14.158 +        public String toString() {
  14.159 +            return "[Range Analysis]";
  14.160 +        }
  14.161 +    },
  14.162 +
  14.163 +
  14.164 +    /*
  14.165       * Splitter Split the AST into several compile units based on a size
  14.166       * heuristic Splitter needs attributed AST for weight calculations (e.g. is
  14.167       * a + b a ScriptRuntime.ADD with call overhead or a dadd with much less).
  14.168 @@ -218,7 +306,6 @@
  14.169          FunctionNode transform(final Compiler compiler, final FunctionNode fn) {
  14.170              final CompileUnit outermostCompileUnit = compiler.addCompileUnit(compiler.firstCompileUnitName());
  14.171  
  14.172 -//            assert fn.isProgram() ;
  14.173              final FunctionNode newFunctionNode = new Splitter(compiler, fn, outermostCompileUnit).split(fn);
  14.174  
  14.175              assert newFunctionNode.getCompileUnit() == outermostCompileUnit : "fn.compileUnit (" + newFunctionNode.getCompileUnit() + ") != " + outermostCompileUnit;

    15.1 --- a/src/jdk/nashorn/internal/codegen/Compiler.java	Thu May 30 10:58:35 2013 -0700
    15.2 +++ b/src/jdk/nashorn/internal/codegen/Compiler.java	Mon Jun 03 23:24:36 2013 -0700
    15.3 @@ -99,7 +99,7 @@
    15.4  
    15.5      private boolean strict;
    15.6  
    15.7 -    private CodeInstaller<ScriptEnvironment> installer;
    15.8 +    private final CodeInstaller<ScriptEnvironment> installer;
    15.9  
   15.10      private final TemporarySymbols temporarySymbols = new TemporarySymbols();
   15.11  
   15.12 @@ -219,6 +219,7 @@
   15.13          CompilationPhase.CONSTANT_FOLDING_PHASE,
   15.14          CompilationPhase.LOWERING_PHASE,
   15.15          CompilationPhase.ATTRIBUTION_PHASE,
   15.16 +        CompilationPhase.RANGE_ANALYSIS_PHASE,
   15.17          CompilationPhase.SPLITTING_PHASE,
   15.18          CompilationPhase.TYPE_FINALIZATION_PHASE,
   15.19          CompilationPhase.BYTECODE_GENERATION_PHASE);
   15.20 @@ -384,6 +385,8 @@
   15.21          if (info) {
   15.22              final StringBuilder sb = new StringBuilder();
   15.23              sb.append("Compile job for '").
   15.24 +                append(newFunctionNode.getSource()).
   15.25 +                append(':').
   15.26                  append(newFunctionNode.getName()).
   15.27                  append("' finished");
   15.28  
   15.29 @@ -487,7 +490,7 @@
   15.30          }
   15.31  
   15.32          if (sb != null) {
   15.33 -            LOG.info(sb);
   15.34 +            LOG.fine(sb);
   15.35          }
   15.36  
   15.37          return rootClass;

    16.1 --- a/src/jdk/nashorn/internal/codegen/CompilerConstants.java	Thu May 30 10:58:35 2013 -0700
    16.2 +++ b/src/jdk/nashorn/internal/codegen/CompilerConstants.java	Mon Jun 03 23:24:36 2013 -0700
    16.3 @@ -262,7 +262,7 @@
    16.4       * @return the internal descriptor for this type
    16.5       */
    16.6      public static String typeDescriptor(final Class<?> clazz) {
    16.7 -        return Type.getDescriptor(clazz);
    16.8 +        return Type.typeFor(clazz).getDescriptor();
    16.9      }
   16.10  
   16.11      /**

    17.1 --- a/src/jdk/nashorn/internal/codegen/FinalizeTypes.java	Thu May 30 10:58:35 2013 -0700
    17.2 +++ b/src/jdk/nashorn/internal/codegen/FinalizeTypes.java	Mon Jun 03 23:24:36 2013 -0700
    17.3 @@ -31,6 +31,7 @@
    17.4  import java.util.ArrayList;
    17.5  import java.util.HashSet;
    17.6  import java.util.List;
    17.7 +
    17.8  import jdk.nashorn.internal.codegen.types.Type;
    17.9  import jdk.nashorn.internal.ir.AccessNode;
   17.10  import jdk.nashorn.internal.ir.Assignment;
   17.11 @@ -84,13 +85,14 @@
   17.12   * and frame optimizations
   17.13   */
   17.14  
   17.15 -final class FinalizeTypes extends NodeOperatorVisitor {
   17.16 +final class FinalizeTypes extends NodeOperatorVisitor<LexicalContext> {
   17.17  
   17.18      private static final DebugLogger LOG = new DebugLogger("finalize");
   17.19  
   17.20      private final TemporarySymbols temporarySymbols;
   17.21  
   17.22      FinalizeTypes(final TemporarySymbols temporarySymbols) {
   17.23 +        super(new LexicalContext());
   17.24          this.temporarySymbols = temporarySymbols;
   17.25      }
   17.26  
   17.27 @@ -233,7 +235,7 @@
   17.28  
   17.29      private boolean symbolIsInteger(Node node) {
   17.30          final Symbol symbol = node.getSymbol();
   17.31 -        assert symbol != null && symbol.getSymbolType().isInteger() : "int coercion expected: " + Debug.id(symbol) + " " + symbol + " " + getLexicalContext().getCurrentFunction().getSource();
   17.32 +        assert symbol != null && symbol.getSymbolType().isInteger() : "int coercion expected: " + Debug.id(symbol) + " " + symbol + " " + lc.getCurrentFunction().getSource();
   17.33          return true;
   17.34      }
   17.35  
   17.36 @@ -382,12 +384,10 @@
   17.37          final Node test   = forNode.getTest();
   17.38          final Node modify = forNode.getModify();
   17.39  
   17.40 -        final LexicalContext lc = getLexicalContext();
   17.41 -
   17.42          if (forNode.isForIn()) {
   17.43              return forNode.setModify(lc, convert(forNode.getModify(), Type.OBJECT)); // NASHORN-400
   17.44          }
   17.45 -        assert test != null || forNode.hasGoto() : "forNode " + forNode + " needs goto and is missing it in " + getLexicalContext().getCurrentFunction();
   17.46 +        assert test != null || forNode.hasGoto() : "forNode " + forNode + " needs goto and is missing it in " + lc.getCurrentFunction();
   17.47  
   17.48          return forNode.
   17.49              setInit(lc, init == null ? null : discard(init)).
   17.50 @@ -419,7 +419,7 @@
   17.51  
   17.52      @Override
   17.53      public Node leaveFunctionNode(final FunctionNode functionNode) {
   17.54 -        return functionNode.setState(getLexicalContext(), CompilationState.FINALIZED);
   17.55 +        return functionNode.setState(lc, CompilationState.FINALIZED);
   17.56      }
   17.57  
   17.58      @Override
   17.59 @@ -450,7 +450,7 @@
   17.60      public Node leaveReturnNode(final ReturnNode returnNode) {
   17.61          final Node expr = returnNode.getExpression();
   17.62          if (expr != null) {
   17.63 -            return returnNode.setExpression(convert(expr, getLexicalContext().getCurrentFunction().getReturnType()));
   17.64 +            return returnNode.setExpression(convert(expr, lc.getCurrentFunction().getReturnType()));
   17.65          }
   17.66          return returnNode;
   17.67      }
   17.68 @@ -482,8 +482,8 @@
   17.69          }
   17.70  
   17.71          return switchNode.
   17.72 -            setExpression(getLexicalContext(), convert(expression, Type.OBJECT)).
   17.73 -            setCases(getLexicalContext(), newCases);
   17.74 +            setExpression(lc, convert(expression, Type.OBJECT)).
   17.75 +            setCases(lc, newCases);
   17.76      }
   17.77  
   17.78      @Override
   17.79 @@ -519,14 +519,14 @@
   17.80      public Node leaveWhileNode(final WhileNode whileNode) {
   17.81          final Node test = whileNode.getTest();
   17.82          if (test != null) {
   17.83 -            return whileNode.setTest(getLexicalContext(), convert(test, Type.BOOLEAN));
   17.84 +            return whileNode.setTest(lc, convert(test, Type.BOOLEAN));
   17.85          }
   17.86          return whileNode;
   17.87      }
   17.88  
   17.89      @Override
   17.90      public Node leaveWithNode(final WithNode withNode) {
   17.91 -        return withNode.setExpression(getLexicalContext(), convert(withNode.getExpression(), Type.OBJECT));
   17.92 +        return withNode.setExpression(lc, convert(withNode.getExpression(), Type.OBJECT));
   17.93      }
   17.94  
   17.95      private static void updateSymbolsLog(final FunctionNode functionNode, final Symbol symbol, final boolean loseSlot) {
   17.96 @@ -550,7 +550,6 @@
   17.97              return; // nothing to do
   17.98          }
   17.99  
  17.100 -        final LexicalContext lc             = getLexicalContext();
  17.101          final FunctionNode   functionNode   = lc.getFunction(block);
  17.102          final boolean        allVarsInScope = functionNode.allVarsInScope();
  17.103          final boolean        isVarArg       = functionNode.isVarArg();
  17.104 @@ -652,7 +651,7 @@
  17.105      private static void setCanBePrimitive(final Node node, final Type to) {
  17.106          final HashSet<Node> exclude = new HashSet<>();
  17.107  
  17.108 -        node.accept(new NodeVisitor() {
  17.109 +        node.accept(new NodeVisitor<LexicalContext>(new LexicalContext()) {
  17.110              private void setCanBePrimitive(final Symbol symbol) {
  17.111                  LOG.info("*** can be primitive symbol ", symbol, " ", Debug.id(symbol));
  17.112                  symbol.setCanBePrimitive(to);
  17.113 @@ -762,7 +761,7 @@
  17.114              }
  17.115          }
  17.116          LOG.info("Type override for lhs in '", node, "' => ", to);
  17.117 -        return ((TypeOverride<T>)node).setType(temporarySymbols, getLexicalContext(), to);
  17.118 +        return ((TypeOverride<T>)node).setType(temporarySymbols, lc, to);
  17.119      }
  17.120  
  17.121      /**
  17.122 @@ -785,8 +784,8 @@
  17.123      private Node convert(final Node node, final Type to) {
  17.124          assert !to.isUnknown() : "unknown type for " + node + " class=" + node.getClass();
  17.125          assert node != null : "node is null";
  17.126 -        assert node.getSymbol() != null : "node " + node + " " + node.getClass() + " has no symbol! " + getLexicalContext().getCurrentFunction();
  17.127 -        assert node.tokenType() != TokenType.CONVERT : "assert convert in convert " + node + " in " + getLexicalContext().getCurrentFunction();
  17.128 +        assert node.getSymbol() != null : "node " + node + " " + node.getClass() + " has no symbol! " + lc.getCurrentFunction();
  17.129 +        assert node.tokenType() != TokenType.CONVERT : "assert convert in convert " + node + " in " + lc.getCurrentFunction();
  17.130  
  17.131          final Type from = node.getType();
  17.132  
  17.133 @@ -800,7 +799,7 @@
  17.134  
  17.135          Node resultNode = node;
  17.136  
  17.137 -        if (node instanceof LiteralNode && !to.isObject()) {
  17.138 +        if (node instanceof LiteralNode && !(node instanceof ArrayLiteralNode) && !to.isObject()) {
  17.139              final LiteralNode<?> newNode = new LiteralNodeConstantEvaluator((LiteralNode<?>)node, to).eval();
  17.140              if (newNode != null) {
  17.141                  resultNode = newNode;
  17.142 @@ -817,7 +816,6 @@
  17.143  
  17.144          assert !node.isTerminal();
  17.145  
  17.146 -        final LexicalContext lc = getLexicalContext();
  17.147          //This is the only place in this file that can create new temporaries
  17.148          //FinalizeTypes may not introduce ANY node that is not a conversion.
  17.149          return temporarySymbols.ensureSymbol(lc, to, resultNode);
  17.150 @@ -854,7 +852,7 @@
  17.151              symbol = symbol.setTypeOverrideShared(to, temporarySymbols);
  17.152              LOG.info("Type override for temporary in '", node, "' => ", to);
  17.153          }
  17.154 -        return node.setSymbol(getLexicalContext(), symbol);
  17.155 +        return node.setSymbol(lc, symbol);
  17.156      }
  17.157  
  17.158      /**
  17.159 @@ -907,7 +905,7 @@
  17.160  
  17.161              if (literalNode != null) {
  17.162                  //inherit literal symbol for attr.
  17.163 -                literalNode = (LiteralNode<?>)literalNode.setSymbol(getLexicalContext(), parent.getSymbol());
  17.164 +                literalNode = (LiteralNode<?>)literalNode.setSymbol(lc, parent.getSymbol());
  17.165              }
  17.166  
  17.167              return literalNode;

    18.1 --- a/src/jdk/nashorn/internal/codegen/FoldConstants.java	Thu May 30 10:58:35 2013 -0700
    18.2 +++ b/src/jdk/nashorn/internal/codegen/FoldConstants.java	Mon Jun 03 23:24:36 2013 -0700
    18.3 @@ -33,7 +33,9 @@
    18.4  import jdk.nashorn.internal.ir.FunctionNode;
    18.5  import jdk.nashorn.internal.ir.FunctionNode.CompilationState;
    18.6  import jdk.nashorn.internal.ir.IfNode;
    18.7 +import jdk.nashorn.internal.ir.LexicalContext;
    18.8  import jdk.nashorn.internal.ir.LiteralNode;
    18.9 +import jdk.nashorn.internal.ir.LiteralNode.ArrayLiteralNode;
   18.10  import jdk.nashorn.internal.ir.Node;
   18.11  import jdk.nashorn.internal.ir.TernaryNode;
   18.12  import jdk.nashorn.internal.ir.UnaryNode;
   18.13 @@ -45,11 +47,12 @@
   18.14  /**
   18.15   * Simple constant folding pass, executed before IR is starting to be lowered.
   18.16   */
   18.17 -final class FoldConstants extends NodeVisitor {
   18.18 +final class FoldConstants extends NodeVisitor<LexicalContext> {
   18.19  
   18.20      private static final DebugLogger LOG = new DebugLogger("fold");
   18.21  
   18.22      FoldConstants() {
   18.23 +        super(new LexicalContext());
   18.24      }
   18.25  
   18.26      @Override
   18.27 @@ -79,7 +82,7 @@
   18.28  
   18.29      @Override
   18.30      public Node leaveFunctionNode(final FunctionNode functionNode) {
   18.31 -        return functionNode.setState(getLexicalContext(), CompilationState.CONSTANT_FOLDED);
   18.32 +        return functionNode.setState(lc, CompilationState.CONSTANT_FOLDED);
   18.33      }
   18.34  
   18.35      @Override
   18.36 @@ -141,6 +144,10 @@
   18.37                  return null;
   18.38              }
   18.39  
   18.40 +            if (rhsNode instanceof ArrayLiteralNode) {
   18.41 +                return null;
   18.42 +            }
   18.43 +
   18.44              final LiteralNode<?> rhs = (LiteralNode<?>)rhsNode;
   18.45              final boolean rhsInteger = rhs.getType().isInteger();
   18.46  
   18.47 @@ -212,6 +219,10 @@
   18.48              final LiteralNode<?> lhs = (LiteralNode<?>)parent.lhs();
   18.49              final LiteralNode<?> rhs = (LiteralNode<?>)parent.rhs();
   18.50  
   18.51 +            if (lhs instanceof ArrayLiteralNode || rhs instanceof ArrayLiteralNode) {
   18.52 +                return null;
   18.53 +            }
   18.54 +
   18.55              final Type widest = Type.widest(lhs.getType(), rhs.getType());
   18.56  
   18.57              boolean isInteger = widest.isInteger();
   18.58 @@ -279,9 +290,9 @@
   18.59              isLong    &= value != 0.0 && JSType.isRepresentableAsLong(value);
   18.60  
   18.61              if (isInteger) {
   18.62 -                return LiteralNode.newInstance(token, finish, JSType.toInt32(value));
   18.63 +                return LiteralNode.newInstance(token, finish, (int)value);
   18.64              } else if (isLong) {
   18.65 -                return LiteralNode.newInstance(token, finish, JSType.toLong(value));
   18.66 +                return LiteralNode.newInstance(token, finish, (long)value);
   18.67              }
   18.68  
   18.69              return LiteralNode.newInstance(token, finish, value);

    19.1 --- a/src/jdk/nashorn/internal/codegen/Lower.java	Thu May 30 10:58:35 2013 -0700
    19.2 +++ b/src/jdk/nashorn/internal/codegen/Lower.java	Mon Jun 03 23:24:36 2013 -0700
    19.3 @@ -80,7 +80,7 @@
    19.4   * finalized.
    19.5   */
    19.6  
    19.7 -final class Lower extends NodeOperatorVisitor {
    19.8 +final class Lower extends NodeOperatorVisitor<BlockLexicalContext> {
    19.9  
   19.10      private static final DebugLogger LOG = new DebugLogger("lower");
   19.11  
   19.12 @@ -105,7 +105,7 @@
   19.13                              terminated = true;
   19.14                          }
   19.15                      } else {
   19.16 -                        statement.accept(new NodeVisitor() {
   19.17 +                        statement.accept(new NodeVisitor<LexicalContext>(new LexicalContext()) {
   19.18                              @Override
   19.19                              public boolean enterVarNode(final VarNode varNode) {
   19.20                                  newStatements.add(varNode.setInit(null));
   19.21 @@ -121,7 +121,6 @@
   19.22  
   19.23      @Override
   19.24      public boolean enterBlock(final Block block) {
   19.25 -        final LexicalContext lc = getLexicalContext();
   19.26          final FunctionNode   function = lc.getCurrentFunction();
   19.27          if (lc.isFunctionBody() && function.isProgram() && !function.hasDeclaredFunctions()) {
   19.28              new ExecuteNode(block.getLineNumber(), block.getToken(), block.getFinish(), LiteralNode.newInstance(block, ScriptRuntime.UNDEFINED)).accept(this);
   19.29 @@ -134,12 +133,10 @@
   19.30          //now we have committed the entire statement list to the block, but we need to truncate
   19.31          //whatever is after the last terminal. block append won't append past it
   19.32  
   19.33 -        final BlockLexicalContext lc = (BlockLexicalContext)getLexicalContext();
   19.34 -
   19.35          Statement last = lc.getLastStatement();
   19.36  
   19.37          if (lc.isFunctionBody()) {
   19.38 -            final FunctionNode currentFunction = getLexicalContext().getCurrentFunction();
   19.39 +            final FunctionNode currentFunction = lc.getCurrentFunction();
   19.40              final boolean isProgram = currentFunction.isProgram();
   19.41              final ReturnNode returnNode = new ReturnNode(
   19.42                  last == null ? block.getLineNumber() : last.getLineNumber(), //TODO?
   19.43 @@ -191,7 +188,7 @@
   19.44          final Node expr = executeNode.getExpression();
   19.45          ExecuteNode node = executeNode;
   19.46  
   19.47 -        final FunctionNode currentFunction = getLexicalContext().getCurrentFunction();
   19.48 +        final FunctionNode currentFunction = lc.getCurrentFunction();
   19.49  
   19.50          if (currentFunction.isProgram()) {
   19.51              if (!(expr instanceof Block) || expr instanceof FunctionNode) { // it's not a block, but can be a function
   19.52 @@ -216,7 +213,7 @@
   19.53  
   19.54          final Node  test = forNode.getTest();
   19.55          if (!forNode.isForIn() && conservativeAlwaysTrue(test)) {
   19.56 -            newForNode = forNode.setTest(getLexicalContext(), null);
   19.57 +            newForNode = forNode.setTest(lc, null);
   19.58          }
   19.59  
   19.60          return addStatement(checkEscape(newForNode));
   19.61 @@ -230,7 +227,7 @@
   19.62      @Override
   19.63      public Node leaveFunctionNode(final FunctionNode functionNode) {
   19.64          LOG.info("END FunctionNode: ", functionNode.getName());
   19.65 -        return functionNode.setState(getLexicalContext(), CompilationState.LOWERED);
   19.66 +        return functionNode.setState(lc, CompilationState.LOWERED);
   19.67      }
   19.68  
   19.69      @Override
   19.70 @@ -261,19 +258,25 @@
   19.71          return throwNode;
   19.72      }
   19.73  
   19.74 -    private static Node ensureUniqueLabelsIn(final Node node) {
   19.75 -        return node.accept(new NodeVisitor() {
   19.76 -           @Override
   19.77 -           public Node leaveDefault(final Node labelledNode) {
   19.78 -               return labelledNode.ensureUniqueLabels(getLexicalContext());
   19.79 -           }
   19.80 +    private static Node ensureUniqueNamesIn(final LexicalContext lc, final Node node) {
   19.81 +        return node.accept(new NodeVisitor<LexicalContext>(new LexicalContext()) {
   19.82 +            @Override
   19.83 +            public Node leaveFunctionNode(final FunctionNode functionNode) {
   19.84 +                final String name = functionNode.getName();
   19.85 +                return functionNode.setName(lc, lc.getCurrentFunction().uniqueName(name));
   19.86 +            }
   19.87 +
   19.88 +            @Override
   19.89 +            public Node leaveDefault(final Node labelledNode) {
   19.90 +                return labelledNode.ensureUniqueLabels(lc);
   19.91 +            }
   19.92          });
   19.93      }
   19.94  
   19.95 -    private static List<Statement> copyFinally(final Block finallyBody) {
   19.96 +    private static List<Statement> copyFinally(final LexicalContext lc, final Block finallyBody) {
   19.97          final List<Statement> newStatements = new ArrayList<>();
   19.98          for (final Statement statement : finallyBody.getStatements()) {
   19.99 -            newStatements.add((Statement)ensureUniqueLabelsIn(statement));
  19.100 +            newStatements.add((Statement)ensureUniqueNamesIn(lc, statement));
  19.101              if (statement.hasTerminalFlags()) {
  19.102                  return newStatements;
  19.103              }
  19.104 @@ -286,12 +289,12 @@
  19.105          final long token      = tryNode.getToken();
  19.106          final int  finish     = tryNode.getFinish();
  19.107  
  19.108 -        final IdentNode exception = new IdentNode(token, finish, getLexicalContext().getCurrentFunction().uniqueName("catch_all"));
  19.109 +        final IdentNode exception = new IdentNode(token, finish, lc.getCurrentFunction().uniqueName("catch_all"));
  19.110  
  19.111 -        final Block catchBody = new Block(lineNumber, token, finish, new ThrowNode(lineNumber, token, finish, new IdentNode(exception))).
  19.112 -                setIsTerminal(getLexicalContext(), true); //ends with throw, so terminal
  19.113 +        final Block catchBody = new Block(lineNumber, token, finish, new ThrowNode(lineNumber, token, finish, new IdentNode(exception), ThrowNode.IS_SYNTHETIC_RETHROW)).
  19.114 +                setIsTerminal(lc, true); //ends with throw, so terminal
  19.115  
  19.116 -        final CatchNode catchAllNode  = new CatchNode(lineNumber, token, finish, new IdentNode(exception), null, catchBody);
  19.117 +        final CatchNode catchAllNode  = new CatchNode(lineNumber, token, finish, new IdentNode(exception), null, catchBody, CatchNode.IS_SYNTHETIC_RETHROW);
  19.118          final Block     catchAllBlock = new Block(lineNumber, token, finish, catchAllNode);
  19.119  
  19.120          //catchallblock -> catchallnode (catchnode) -> exception -> throw
  19.121 @@ -300,7 +303,7 @@
  19.122      }
  19.123  
  19.124      private IdentNode compilerConstant(final CompilerConstants cc) {
  19.125 -        final FunctionNode functionNode = getLexicalContext().getCurrentFunction();
  19.126 +        final FunctionNode functionNode = lc.getCurrentFunction();
  19.127          return new IdentNode(functionNode.getToken(), functionNode.getFinish(), cc.symbolName());
  19.128      }
  19.129  
  19.130 @@ -316,11 +319,10 @@
  19.131       * @return new try node after splicing finally code (same if nop)
  19.132       */
  19.133      private Node spliceFinally(final TryNode tryNode, final List<ThrowNode> rethrows, final Block finallyBody) {
  19.134 -        final int finish = tryNode.getFinish();
  19.135 +        assert tryNode.getFinallyBody() == null;
  19.136 +        final int            finish = tryNode.getFinish();
  19.137  
  19.138 -        assert tryNode.getFinallyBody() == null;
  19.139 -
  19.140 -        final TryNode newTryNode = (TryNode)tryNode.accept(new NodeVisitor() {
  19.141 +        final TryNode newTryNode = (TryNode)tryNode.accept(new NodeVisitor<LexicalContext>(new LexicalContext()) {
  19.142              final List<Node> insideTry = new ArrayList<>();
  19.143  
  19.144              @Override
  19.145 @@ -338,7 +340,7 @@
  19.146              @Override
  19.147              public Node leaveThrowNode(final ThrowNode throwNode) {
  19.148                  if (rethrows.contains(throwNode)) {
  19.149 -                    final List<Statement> newStatements = copyFinally(finallyBody);
  19.150 +                    final List<Statement> newStatements = copyFinally(lc, finallyBody);
  19.151                      if (!isTerminal(newStatements)) {
  19.152                          newStatements.add(throwNode);
  19.153                      }
  19.154 @@ -349,12 +351,12 @@
  19.155  
  19.156              @Override
  19.157              public Node leaveBreakNode(final BreakNode breakNode) {
  19.158 -                return copy(breakNode, Lower.this.getLexicalContext().getBreakable(breakNode.getLabel()));
  19.159 +                return copy(breakNode, Lower.this.lc.getBreakable(breakNode.getLabel()));
  19.160              }
  19.161  
  19.162              @Override
  19.163              public Node leaveContinueNode(final ContinueNode continueNode) {
  19.164 -                return copy(continueNode, Lower.this.getLexicalContext().getContinueTo(continueNode.getLabel()));
  19.165 +                return copy(continueNode, Lower.this.lc.getContinueTo(continueNode.getLabel()));
  19.166              }
  19.167  
  19.168              @Override
  19.169 @@ -372,17 +374,17 @@
  19.170                      resultNode = null;
  19.171                  }
  19.172  
  19.173 -                newStatements.addAll(copyFinally(finallyBody));
  19.174 +                newStatements.addAll(copyFinally(lc, finallyBody));
  19.175                  if (!isTerminal(newStatements)) {
  19.176                      newStatements.add(expr == null ? returnNode : returnNode.setExpression(resultNode));
  19.177                  }
  19.178  
  19.179 -                return new ExecuteNode(returnNode.getLineNumber(), returnNode.getToken(), returnNode.getFinish(), new Block(returnNode.getLineNumber(), returnNode.getToken(), getLexicalContext().getCurrentBlock().getFinish(), newStatements));
  19.180 +                return new ExecuteNode(returnNode.getLineNumber(), returnNode.getToken(), returnNode.getFinish(), new Block(returnNode.getLineNumber(), returnNode.getToken(), lc.getCurrentBlock().getFinish(), newStatements));
  19.181              }
  19.182  
  19.183              private Node copy(final Statement endpoint, final Node targetNode) {
  19.184                  if (!insideTry.contains(targetNode)) {
  19.185 -                    final List<Statement> newStatements = copyFinally(finallyBody);
  19.186 +                    final List<Statement> newStatements = copyFinally(lc, finallyBody);
  19.187                      if (!isTerminal(newStatements)) {
  19.188                          newStatements.add(endpoint);
  19.189                      }
  19.190 @@ -436,7 +438,7 @@
  19.191          final Block catchAll = catchAllBlock(tryNode);
  19.192  
  19.193          final List<ThrowNode> rethrows = new ArrayList<>();
  19.194 -        catchAll.accept(new NodeVisitor() {
  19.195 +        catchAll.accept(new NodeVisitor<LexicalContext>(new LexicalContext()) {
  19.196              @Override
  19.197              public boolean enterThrowNode(final ThrowNode throwNode) {
  19.198                  rethrows.add(throwNode);
  19.199 @@ -464,7 +466,7 @@
  19.200      @Override
  19.201      public Node leaveVarNode(final VarNode varNode) {
  19.202          addStatement(varNode);
  19.203 -        if (varNode.getFlag(VarNode.IS_LAST_FUNCTION_DECLARATION) && getLexicalContext().getCurrentFunction().isProgram()) {
  19.204 +        if (varNode.getFlag(VarNode.IS_LAST_FUNCTION_DECLARATION) && lc.getCurrentFunction().isProgram()) {
  19.205              new ExecuteNode(varNode.getLineNumber(), varNode.getToken(), varNode.getFinish(), new IdentNode(varNode.getName())).accept(this);
  19.206          }
  19.207          return varNode;
  19.208 @@ -478,7 +480,7 @@
  19.209          if (conservativeAlwaysTrue(test)) {
  19.210              //turn it into a for node without a test.
  19.211              final ForNode forNode = (ForNode)new ForNode(whileNode.getLineNumber(), whileNode.getToken(), whileNode.getFinish(), null, null, body, null, ForNode.IS_FOR).accept(this);
  19.212 -            getLexicalContext().replace(whileNode, forNode);
  19.213 +            lc.replace(whileNode, forNode);
  19.214              return forNode;
  19.215          }
  19.216  
  19.217 @@ -513,7 +515,7 @@
  19.218       * @return eval location
  19.219       */
  19.220      private String evalLocation(final IdentNode node) {
  19.221 -        final Source source = getLexicalContext().getCurrentFunction().getSource();
  19.222 +        final Source source = lc.getCurrentFunction().getSource();
  19.223          return new StringBuilder().
  19.224              append(source.getName()).
  19.225              append('#').
  19.226 @@ -545,10 +547,10 @@
  19.227  
  19.228              // 'eval' call with at least one argument
  19.229              if (args.size() >= 1 && EVAL.symbolName().equals(callee.getName())) {
  19.230 -                final FunctionNode currentFunction = getLexicalContext().getCurrentFunction();
  19.231 +                final FunctionNode currentFunction = lc.getCurrentFunction();
  19.232                  return callNode.setEvalArgs(
  19.233                      new CallNode.EvalArgs(
  19.234 -                        ensureUniqueLabelsIn(args.get(0)).accept(this),
  19.235 +                        ensureUniqueNamesIn(lc, args.get(0)).accept(this),
  19.236                          compilerConstant(THIS),
  19.237                          evalLocation(callee),
  19.238                          currentFunction.isStrict()));
  19.239 @@ -574,7 +576,7 @@
  19.240      private static boolean controlFlowEscapes(final LexicalContext lex, final Block loopBody) {
  19.241          final List<Node> escapes = new ArrayList<>();
  19.242  
  19.243 -        loopBody.accept(new NodeVisitor() {
  19.244 +        loopBody.accept(new NodeVisitor<LexicalContext>(new LexicalContext()) {
  19.245              @Override
  19.246              public Node leaveBreakNode(final BreakNode node) {
  19.247                  escapes.add(node);
  19.248 @@ -595,7 +597,6 @@
  19.249      }
  19.250  
  19.251      private LoopNode checkEscape(final LoopNode loopNode) {
  19.252 -        final LexicalContext lc = getLexicalContext();
  19.253          final boolean escapes = controlFlowEscapes(lc, loopNode.getBody());
  19.254          if (escapes) {
  19.255              return loopNode.
  19.256 @@ -607,7 +608,7 @@
  19.257  
  19.258  
  19.259      private Node addStatement(final Statement statement) {
  19.260 -        ((BlockLexicalContext)getLexicalContext()).appendStatement(statement);
  19.261 +        lc.appendStatement(statement);
  19.262          return statement;
  19.263      }
  19.264  

    20.1 --- a/src/jdk/nashorn/internal/codegen/MethodEmitter.java	Thu May 30 10:58:35 2013 -0700
    20.2 +++ b/src/jdk/nashorn/internal/codegen/MethodEmitter.java	Mon Jun 03 23:24:36 2013 -0700
    20.3 @@ -2081,7 +2081,9 @@
    20.4       * @param args debug information to print
    20.5       */
    20.6      private void debug(final Object... args) {
    20.7 -        debug(30, args);
    20.8 +        if (DEBUG) {
    20.9 +            debug(30, args);
   20.10 +        }
   20.11      }
   20.12  
   20.13      /**
   20.14 @@ -2091,7 +2093,9 @@
   20.15       * @param args debug information to print
   20.16       */
   20.17      private void debug_label(final Object... args) {
   20.18 -        debug(26, args);
   20.19 +        if (DEBUG) {
   20.20 +            debug(22, args);
   20.21 +        }
   20.22      }
   20.23  
   20.24      private void debug(final int padConstant, final Object... args) {
   20.25 @@ -2164,7 +2168,6 @@
   20.26                      new Throwable().printStackTrace(LOG.getOutputStream());
   20.27                  }
   20.28              }
   20.29 -
   20.30          }
   20.31      }
   20.32  

    21.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    21.2 +++ b/src/jdk/nashorn/internal/codegen/RangeAnalyzer.java	Mon Jun 03 23:24:36 2013 -0700
    21.3 @@ -0,0 +1,476 @@
    21.4 +/*
    21.5 + * Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.
    21.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    21.7 + *
    21.8 + * This code is free software; you can redistribute it and/or modify it
    21.9 + * under the terms of the GNU General Public License version 2 only, as
   21.10 + * published by the Free Software Foundation.  Oracle designates this
   21.11 + * particular file as subject to the "Classpath" exception as provided
   21.12 + * by Oracle in the LICENSE file that accompanied this code.
   21.13 + *
   21.14 + * This code is distributed in the hope that it will be useful, but WITHOUT
   21.15 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   21.16 + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   21.17 + * version 2 for more details (a copy is included in the LICENSE file that
   21.18 + * accompanied this code).
   21.19 + *
   21.20 + * You should have received a copy of the GNU General Public License version
   21.21 + * 2 along with this work; if not, write to the Free Software Foundation,
   21.22 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   21.23 + *
   21.24 + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
   21.25 + * or visit www.oracle.com if you need additional information or have any
   21.26 + * questions.
   21.27 + */
   21.28 +
   21.29 +package jdk.nashorn.internal.codegen;
   21.30 +
   21.31 +import java.util.HashMap;
   21.32 +import java.util.HashSet;
   21.33 +import java.util.Map;
   21.34 +
   21.35 +import jdk.nashorn.internal.codegen.types.Range;
   21.36 +import jdk.nashorn.internal.codegen.types.Type;
   21.37 +import jdk.nashorn.internal.ir.Assignment;
   21.38 +import jdk.nashorn.internal.ir.BinaryNode;
   21.39 +import jdk.nashorn.internal.ir.ForNode;
   21.40 +import jdk.nashorn.internal.ir.IdentNode;
   21.41 +import jdk.nashorn.internal.ir.LexicalContext;
   21.42 +import jdk.nashorn.internal.ir.LiteralNode;
   21.43 +import jdk.nashorn.internal.ir.LiteralNode.ArrayLiteralNode;
   21.44 +import jdk.nashorn.internal.ir.LoopNode;
   21.45 +import jdk.nashorn.internal.ir.Node;
   21.46 +import jdk.nashorn.internal.ir.RuntimeNode;
   21.47 +import jdk.nashorn.internal.ir.Symbol;
   21.48 +import jdk.nashorn.internal.ir.UnaryNode;
   21.49 +import jdk.nashorn.internal.ir.VarNode;
   21.50 +import jdk.nashorn.internal.ir.visitor.NodeOperatorVisitor;
   21.51 +import jdk.nashorn.internal.ir.visitor.NodeVisitor;
   21.52 +import jdk.nashorn.internal.parser.TokenType;
   21.53 +import jdk.nashorn.internal.runtime.DebugLogger;
   21.54 +
   21.55 +/**
   21.56 + * Range analysis and narrowing of type where it can be proven
   21.57 + * that there is no spillover, e.g.
   21.58 + *
   21.59 + *  function func(c) {
   21.60 + *    var v = c & 0xfff;
   21.61 + *    var w = c & 0xeee;
   21.62 + *    var x = v * w;
   21.63 + *    return x;
   21.64 + *  }
   21.65 + *
   21.66 + *  Proves that the multiplication never exceeds 24 bits and can thus be an int
   21.67 + */
   21.68 +final class RangeAnalyzer extends NodeOperatorVisitor<LexicalContext> {
   21.69 +    static final DebugLogger LOG = new DebugLogger("ranges");
   21.70 +
   21.71 +    private static final Range.Functionality RANGE = new Range.Functionality(LOG);
   21.72 +
   21.73 +    private final Map<LoopNode, Symbol> loopCounters = new HashMap<>();
   21.74 +
   21.75 +    RangeAnalyzer() {
   21.76 +        super(new LexicalContext());
   21.77 +    }
   21.78 +
   21.79 +    @Override
   21.80 +    public boolean enterForNode(final ForNode forNode) {
   21.81 +        //conservatively attempt to identify the loop counter. Null means that it wasn't
   21.82 +        //properly identified and that no optimizations can be made with it - its range is
   21.83 +        //simply unknown in that case, if it is assigned in the loop
   21.84 +        final Symbol counter = findLoopCounter(forNode);
   21.85 +        LOG.fine("Entering forNode " + forNode + " counter = " + counter);
   21.86 +        if (counter != null && !assignedInLoop(forNode,  counter)) {
   21.87 +            loopCounters.put(forNode, counter);
   21.88 +        }
   21.89 +        return true;
   21.90 +    }
   21.91 +
   21.92 +    //destination visited
   21.93 +    private Symbol setRange(final Node dest, final Range range) {
   21.94 +        if (range.isUnknown()) {
   21.95 +            return null;
   21.96 +        }
   21.97 +
   21.98 +        final Symbol symbol = dest.getSymbol();
   21.99 +        assert symbol != null : dest + " " + dest.getClass() + " has no symbol";
  21.100 +        assert symbol.getRange() != null : symbol + " has no range";
  21.101 +        final Range symRange = RANGE.join(symbol.getRange(), range);
  21.102 +
  21.103 +        //anything assigned in the loop, not being the safe loop counter(s) invalidates its entire range
  21.104 +        if (lc.inLoop() && !isLoopCounter(lc.getCurrentLoop(), symbol)) {
  21.105 +            symbol.setRange(Range.createGenericRange());
  21.106 +            return symbol;
  21.107 +        }
  21.108 +
  21.109 +        if (!symRange.equals(symbol.getRange())) {
  21.110 +            LOG.fine("Modify range for " + dest + " " + symbol + " from " + symbol.getRange() + " to " + symRange + " (in node = " + dest + ")" );
  21.111 +            symbol.setRange(symRange);
  21.112 +        }
  21.113 +
  21.114 +        return null;
  21.115 +    }
  21.116 +
  21.117 +    @Override
  21.118 +    public Node leaveADD(final BinaryNode node) {
  21.119 +        setRange(node, RANGE.add(node.lhs().getSymbol().getRange(), node.rhs().getSymbol().getRange()));
  21.120 +        return node;
  21.121 +    }
  21.122 +
  21.123 +    @Override
  21.124 +    public Node leaveSUB(final BinaryNode node) {
  21.125 +        setRange(node, RANGE.sub(node.lhs().getSymbol().getRange(), node.rhs().getSymbol().getRange()));
  21.126 +        return node;
  21.127 +    }
  21.128 +
  21.129 +    @Override
  21.130 +    public Node leaveMUL(final BinaryNode node) {
  21.131 +        setRange(node, RANGE.mul(node.lhs().getSymbol().getRange(), node.rhs().getSymbol().getRange()));
  21.132 +        return node;
  21.133 +    }
  21.134 +
  21.135 +    @Override
  21.136 +    public Node leaveDIV(final BinaryNode node) {
  21.137 +        setRange(node, RANGE.div(node.lhs().getSymbol().getRange(), node.rhs().getSymbol().getRange()));
  21.138 +        return node;
  21.139 +    }
  21.140 +
  21.141 +    @Override
  21.142 +    public Node leaveMOD(final BinaryNode node) {
  21.143 +        setRange(node, RANGE.mod(node.lhs().getSymbol().getRange(), node.rhs().getSymbol().getRange()));
  21.144 +        return node;
  21.145 +    }
  21.146 +
  21.147 +    @Override
  21.148 +    public Node leaveBIT_AND(final BinaryNode node) {
  21.149 +        setRange(node, RANGE.and(node.lhs().getSymbol().getRange(), node.rhs().getSymbol().getRange()));
  21.150 +        return node;
  21.151 +    }
  21.152 +
  21.153 +    @Override
  21.154 +    public Node leaveBIT_OR(final BinaryNode node) {
  21.155 +        setRange(node, RANGE.or(node.lhs().getSymbol().getRange(), node.rhs().getSymbol().getRange()));
  21.156 +        return node;
  21.157 +    }
  21.158 +
  21.159 +    @Override
  21.160 +    public Node leaveBIT_XOR(final BinaryNode node) {
  21.161 +        setRange(node, RANGE.xor(node.lhs().getSymbol().getRange(), node.rhs().getSymbol().getRange()));
  21.162 +        return node;
  21.163 +    }
  21.164 +
  21.165 +    @Override
  21.166 +    public Node leaveSAR(final BinaryNode node) {
  21.167 +        setRange(node, RANGE.sar(node.lhs().getSymbol().getRange(), node.rhs().getSymbol().getRange()));
  21.168 +        return node;
  21.169 +    }
  21.170 +
  21.171 +    @Override
  21.172 +    public Node leaveSHL(final BinaryNode node) {
  21.173 +        setRange(node, RANGE.shl(node.lhs().getSymbol().getRange(), node.rhs().getSymbol().getRange()));
  21.174 +        return node;
  21.175 +    }
  21.176 +
  21.177 +    @Override
  21.178 +    public Node leaveSHR(final BinaryNode node) {
  21.179 +        setRange(node, RANGE.shr(node.lhs().getSymbol().getRange(), node.rhs().getSymbol().getRange()));
  21.180 +        return node;
  21.181 +    }
  21.182 +
  21.183 +    private Node leaveCmp(final BinaryNode node) {
  21.184 +        setRange(node, Range.createTypeRange(Type.BOOLEAN));
  21.185 +        return node;
  21.186 +    }
  21.187 +
  21.188 +    @Override
  21.189 +    public Node leaveEQ(final BinaryNode node) {
  21.190 +        return leaveCmp(node);
  21.191 +    }
  21.192 +
  21.193 +    @Override
  21.194 +    public Node leaveEQ_STRICT(final BinaryNode node) {
  21.195 +        return leaveCmp(node);
  21.196 +    }
  21.197 +
  21.198 +    @Override
  21.199 +    public Node leaveNE(final BinaryNode node) {
  21.200 +        return leaveCmp(node);
  21.201 +    }
  21.202 +
  21.203 +    @Override
  21.204 +    public Node leaveNE_STRICT(final BinaryNode node) {
  21.205 +        return leaveCmp(node);
  21.206 +    }
  21.207 +
  21.208 +    @Override
  21.209 +    public Node leaveLT(final BinaryNode node) {
  21.210 +        return leaveCmp(node);
  21.211 +    }
  21.212 +
  21.213 +    @Override
  21.214 +    public Node leaveLE(final BinaryNode node) {
  21.215 +        return leaveCmp(node);
  21.216 +    }
  21.217 +
  21.218 +    @Override
  21.219 +    public Node leaveGT(final BinaryNode node) {
  21.220 +        return leaveCmp(node);
  21.221 +    }
  21.222 +
  21.223 +    @Override
  21.224 +    public Node leaveGE(final BinaryNode node) {
  21.225 +        return leaveCmp(node);
  21.226 +    }
  21.227 +
  21.228 +    @Override
  21.229 +    public Node leaveASSIGN(final BinaryNode node) {
  21.230 +        Range range = node.rhs().getSymbol().getRange();
  21.231 +        if (range.isUnknown()) {
  21.232 +            range = Range.createGenericRange();
  21.233 +        }
  21.234 +
  21.235 +        setRange(node.lhs(), range);
  21.236 +        setRange(node, range);
  21.237 +
  21.238 +        return node;
  21.239 +    }
  21.240 +
  21.241 +    private Node leaveSelfModifyingAssign(final BinaryNode node, final Range range) {
  21.242 +        setRange(node.lhs(), range);
  21.243 +        setRange(node, range);
  21.244 +        return node;
  21.245 +    }
  21.246 +
  21.247 +    private Node leaveSelfModifyingAssign(final UnaryNode node, final Range range) {
  21.248 +        setRange(node.rhs(), range);
  21.249 +        setRange(node, range);
  21.250 +        return node;
  21.251 +    }
  21.252 +
  21.253 +    @Override
  21.254 +    public Node leaveASSIGN_ADD(final BinaryNode node) {
  21.255 +        return leaveSelfModifyingAssign(node, RANGE.add(node.lhs().getSymbol().getRange(), node.rhs().getSymbol().getRange()));
  21.256 +    }
  21.257 +
  21.258 +    @Override
  21.259 +    public Node leaveASSIGN_SUB(final BinaryNode node) {
  21.260 +        return leaveSelfModifyingAssign(node, RANGE.sub(node.lhs().getSymbol().getRange(), node.rhs().getSymbol().getRange()));
  21.261 +    }
  21.262 +
  21.263 +    @Override
  21.264 +    public Node leaveASSIGN_MUL(final BinaryNode node) {
  21.265 +        return leaveSelfModifyingAssign(node, RANGE.mul(node.lhs().getSymbol().getRange(), node.rhs().getSymbol().getRange()));
  21.266 +    }
  21.267 +
  21.268 +    @Override
  21.269 +    public Node leaveASSIGN_DIV(final BinaryNode node) {
  21.270 +        return leaveSelfModifyingAssign(node, Range.createTypeRange(Type.NUMBER));
  21.271 +    }
  21.272 +
  21.273 +    @Override
  21.274 +    public Node leaveASSIGN_MOD(final BinaryNode node) {
  21.275 +        return leaveSelfModifyingAssign(node, Range.createTypeRange(Type.NUMBER));
  21.276 +    }
  21.277 +
  21.278 +    @Override
  21.279 +    public Node leaveASSIGN_BIT_AND(final BinaryNode node) {
  21.280 +        return leaveSelfModifyingAssign(node, RANGE.and(node.lhs().getSymbol().getRange(), node.rhs().getSymbol().getRange()));
  21.281 +    }
  21.282 +
  21.283 +    @Override
  21.284 +    public Node leaveASSIGN_BIT_OR(final BinaryNode node) {
  21.285 +        return leaveSelfModifyingAssign(node, RANGE.or(node.lhs().getSymbol().getRange(), node.rhs().getSymbol().getRange()));
  21.286 +    }
  21.287 +
  21.288 +    @Override
  21.289 +    public Node leaveASSIGN_BIT_XOR(final BinaryNode node) {
  21.290 +        return leaveSelfModifyingAssign(node, RANGE.xor(node.lhs().getSymbol().getRange(), node.rhs().getSymbol().getRange()));
  21.291 +    }
  21.292 +
  21.293 +    @Override
  21.294 +    public Node leaveASSIGN_SAR(final BinaryNode node) {
  21.295 +        return leaveSelfModifyingAssign(node, RANGE.sar(node.lhs().getSymbol().getRange(), node.rhs().getSymbol().getRange()));
  21.296 +    }
  21.297 +
  21.298 +    @Override
  21.299 +    public Node leaveASSIGN_SHR(final BinaryNode node) {
  21.300 +        return leaveSelfModifyingAssign(node, RANGE.shr(node.lhs().getSymbol().getRange(), node.rhs().getSymbol().getRange()));
  21.301 +    }
  21.302 +
  21.303 +    @Override
  21.304 +    public Node leaveASSIGN_SHL(final BinaryNode node) {
  21.305 +        return leaveSelfModifyingAssign(node, RANGE.shl(node.lhs().getSymbol().getRange(), node.rhs().getSymbol().getRange()));
  21.306 +    }
  21.307 +
  21.308 +    @Override
  21.309 +    public Node leaveDECINC(final UnaryNode node) {
  21.310 +        switch (node.tokenType()) {
  21.311 +        case DECPREFIX:
  21.312 +        case DECPOSTFIX:
  21.313 +            return leaveSelfModifyingAssign(node, RANGE.sub(node.rhs().getSymbol().getRange(), Range.createRange(1)));
  21.314 +        case INCPREFIX:
  21.315 +        case INCPOSTFIX:
  21.316 +            return leaveSelfModifyingAssign(node, RANGE.add(node.rhs().getSymbol().getRange(), Range.createRange(1)));
  21.317 +        default:
  21.318 +            assert false;
  21.319 +            return node;
  21.320 +        }
  21.321 +    }
  21.322 +
  21.323 +    @Override
  21.324 +    public Node leaveADD(final UnaryNode node) {
  21.325 +        Range range = node.rhs().getSymbol().getRange();
  21.326 +        if (!range.getType().isNumeric()) {
  21.327 +           range = Range.createTypeRange(Type.NUMBER);
  21.328 +        }
  21.329 +        setRange(node, range);
  21.330 +        return node;
  21.331 +    }
  21.332 +
  21.333 +    @Override
  21.334 +    public Node leaveBIT_NOT(final UnaryNode node) {
  21.335 +        setRange(node, Range.createTypeRange(Type.INT));
  21.336 +        return node;
  21.337 +    }
  21.338 +
  21.339 +    @Override
  21.340 +    public Node leaveNOT(final UnaryNode node) {
  21.341 +        setRange(node, Range.createTypeRange(Type.BOOLEAN));
  21.342 +        return node;
  21.343 +    }
  21.344 +
  21.345 +    @Override
  21.346 +    public Node leaveSUB(final UnaryNode node) {
  21.347 +        setRange(node, RANGE.neg(node.rhs().getSymbol().getRange()));
  21.348 +        return node;
  21.349 +    }
  21.350 +
  21.351 +    @Override
  21.352 +    public Node leaveVarNode(final VarNode node) {
  21.353 +        if (node.isAssignment()) {
  21.354 +            Range range = node.getInit().getSymbol().getRange();
  21.355 +            range = range.isUnknown() ? Range.createGenericRange() : range;
  21.356 +
  21.357 +            setRange(node.getName(), range);
  21.358 +            setRange(node, range);
  21.359 +        }
  21.360 +
  21.361 +        return node;
  21.362 +    }
  21.363 +
  21.364 +    @SuppressWarnings("rawtypes")
  21.365 +    @Override
  21.366 +    public boolean enterLiteralNode(final LiteralNode node) {
  21.367 +        // ignore array literals
  21.368 +        return !(node instanceof ArrayLiteralNode);
  21.369 +    }
  21.370 +
  21.371 +    @Override
  21.372 +    public Node leaveLiteralNode(@SuppressWarnings("rawtypes") final LiteralNode node) {
  21.373 +        if (node.getType().isInteger()) {
  21.374 +            setRange(node, Range.createRange(node.getInt32()));
  21.375 +        } else if (node.getType().isNumber()) {
  21.376 +            setRange(node, Range.createRange(node.getNumber()));
  21.377 +        } else if (node.getType().isLong()) {
  21.378 +            setRange(node, Range.createRange(node.getLong()));
  21.379 +        } else if (node.getType().isBoolean()) {
  21.380 +            setRange(node, Range.createTypeRange(Type.BOOLEAN));
  21.381 +        } else {
  21.382 +            setRange(node, Range.createGenericRange());
  21.383 +        }
  21.384 +        return node;
  21.385 +    }
  21.386 +
  21.387 +    @Override
  21.388 +    public boolean enterRuntimeNode(final RuntimeNode node) {
  21.389 +        // a runtime node that cannot be specialized is no point entering
  21.390 +        return node.getRequest().canSpecialize();
  21.391 +    }
  21.392 +
  21.393 +    /**
  21.394 +     * Check whether a symbol is unsafely assigned in a loop - i.e. repeteadly assigned and
  21.395 +     * not being identified as the loop counter. That means we don't really know anything
  21.396 +     * about its range.
  21.397 +     * @param loopNode loop node
  21.398 +     * @param symbol   symbol
  21.399 +     * @return true if assigned in loop
  21.400 +     */
  21.401 +    // TODO - this currently checks for nodes only - needs to be augmented for while nodes
  21.402 +    // assignment analysis is also very conservative
  21.403 +    private static boolean assignedInLoop(final LoopNode loopNode, final Symbol symbol) {
  21.404 +        final HashSet<Node> skip = new HashSet<>();
  21.405 +        final HashSet<Node> assignmentsInLoop = new HashSet<>();
  21.406 +
  21.407 +        loopNode.accept(new NodeVisitor<LexicalContext>(new LexicalContext()) {
  21.408 +            private boolean assigns(final Node node, final Symbol s) {
  21.409 +                return node.isAssignment() && ((Assignment<?>)node).getAssignmentDest().getSymbol() == s;
  21.410 +            }
  21.411 +
  21.412 +            @Override
  21.413 +            public boolean enterForNode(final ForNode forNode) {
  21.414 +                if (forNode.getInit() != null) {
  21.415 +                    skip.add(forNode.getInit());
  21.416 +                }
  21.417 +                if (forNode.getModify() != null) {
  21.418 +                    skip.add(forNode.getModify());
  21.419 +                }
  21.420 +                return true;
  21.421 +            }
  21.422 +
  21.423 +            @Override
  21.424 +            public Node leaveDefault(final Node node) {
  21.425 +                //if this is an assignment to symbol
  21.426 +                if (!skip.contains(node) && assigns(node, symbol)) {
  21.427 +                    assignmentsInLoop.add(node);
  21.428 +                }
  21.429 +                return node;
  21.430 +            }
  21.431 +        });
  21.432 +
  21.433 +        return !assignmentsInLoop.isEmpty();
  21.434 +    }
  21.435 +
  21.436 +    /**
  21.437 +     * Check for a loop counter. This is currently quite conservative, in that it only handles
  21.438 +     * x <= counter and x < counter.
  21.439 +     *
  21.440 +     * @param node loop node to check
  21.441 +     * @return
  21.442 +     */
  21.443 +    private static Symbol findLoopCounter(final LoopNode node) {
  21.444 +        final Node test = node.getTest();
  21.445 +
  21.446 +        if (test != null && test.isComparison()) {
  21.447 +            final BinaryNode binaryNode = (BinaryNode)test;
  21.448 +            final Node lhs = binaryNode.lhs();
  21.449 +            final Node rhs = binaryNode.rhs();
  21.450 +
  21.451 +            //detect ident cmp int_literal
  21.452 +            if (lhs instanceof IdentNode && rhs instanceof LiteralNode && ((LiteralNode<?>)rhs).getType().isInteger()) {
  21.453 +                final Symbol    symbol = lhs.getSymbol();
  21.454 +                final int       margin = ((LiteralNode<?>)rhs).getInt32();
  21.455 +                final TokenType op     = test.tokenType();
  21.456 +
  21.457 +                switch (op) {
  21.458 +                case LT:
  21.459 +                case LE:
  21.460 +                    symbol.setRange(RANGE.join(symbol.getRange(), Range.createRange(op == TokenType.LT ? margin - 1 : margin)));
  21.461 +                    return symbol;
  21.462 +                case GT:
  21.463 +                case GE:
  21.464 +                    //setRange(lhs, Range.createRange(op == TokenType.GT ? margin + 1 : margin));
  21.465 +                    //return symbol;
  21.466 +                default:
  21.467 +                    break;
  21.468 +                }
  21.469 +            }
  21.470 +        }
  21.471 +
  21.472 +        return null;
  21.473 +    }
  21.474 +
  21.475 +    private boolean isLoopCounter(final LoopNode loopNode, final Symbol symbol) {
  21.476 +        //this only works if loop nodes aren't replaced by other ones during this transform, but they are not
  21.477 +        return loopCounters.get(loopNode) == symbol;
  21.478 +    }
  21.479 +}

    22.1 --- a/src/jdk/nashorn/internal/codegen/SharedScopeCall.java	Thu May 30 10:58:35 2013 -0700
    22.2 +++ b/src/jdk/nashorn/internal/codegen/SharedScopeCall.java	Mon Jun 03 23:24:36 2013 -0700
    22.3 @@ -116,9 +116,10 @@
    22.4      /**
    22.5       * Generate the invoke instruction for this shared scope call.
    22.6       * @param method the method emitter
    22.7 +     * @return the method emitter
    22.8       */
    22.9 -    public void generateInvoke(final MethodEmitter method) {
   22.10 -        method.invokestatic(compileUnit.getUnitClassName(), methodName, getStaticSignature());
   22.11 +    public MethodEmitter generateInvoke(final MethodEmitter method) {
   22.12 +        return method.invokestatic(compileUnit.getUnitClassName(), methodName, getStaticSignature());
   22.13      }
   22.14  
   22.15      /**

    23.1 --- a/src/jdk/nashorn/internal/codegen/Splitter.java	Thu May 30 10:58:35 2013 -0700
    23.2 +++ b/src/jdk/nashorn/internal/codegen/Splitter.java	Mon Jun 03 23:24:36 2013 -0700
    23.3 @@ -49,12 +49,12 @@
    23.4  /**
    23.5   * Split the IR into smaller compile units.
    23.6   */
    23.7 -final class Splitter extends NodeVisitor {
    23.8 +final class Splitter extends NodeVisitor<LexicalContext> {
    23.9      /** Current compiler. */
   23.10      private final Compiler compiler;
   23.11  
   23.12      /** IR to be broken down. */
   23.13 -    private FunctionNode outermost;
   23.14 +    private final FunctionNode outermost;
   23.15  
   23.16      /** Compile unit for the main script. */
   23.17      private final CompileUnit outermostCompileUnit;
   23.18 @@ -75,6 +75,7 @@
   23.19       * @param outermostCompileUnit  compile unit for outermost function, if non-lazy this is the script's compile unit
   23.20       */
   23.21      public Splitter(final Compiler compiler, final FunctionNode functionNode, final CompileUnit outermostCompileUnit) {
   23.22 +        super(new LexicalContext());
   23.23          this.compiler             = compiler;
   23.24          this.outermost            = functionNode;
   23.25          this.outermostCompileUnit = outermostCompileUnit;
   23.26 @@ -93,8 +94,6 @@
   23.27  
   23.28          LOG.finest("Initiating split of '", functionNode.getName(), "'");
   23.29  
   23.30 -        final LexicalContext lc = getLexicalContext();
   23.31 -
   23.32          long weight = WeighNodes.weigh(functionNode);
   23.33          final boolean top = fn.isProgram(); //compiler.getFunctionNode() == outermost;
   23.34  
   23.35 @@ -127,7 +126,7 @@
   23.36          final Block body = functionNode.getBody();
   23.37          final List<FunctionNode> dc = directChildren(functionNode);
   23.38  
   23.39 -        final Block newBody = (Block)body.accept(new NodeVisitor() {
   23.40 +        final Block newBody = (Block)body.accept(new NodeVisitor<LexicalContext>(new LexicalContext()) {
   23.41              @Override
   23.42              public boolean enterFunctionNode(final FunctionNode nestedFunction) {
   23.43                  return dc.contains(nestedFunction);
   23.44 @@ -136,7 +135,7 @@
   23.45              @Override
   23.46              public Node leaveFunctionNode(final FunctionNode nestedFunction) {
   23.47                  FunctionNode split = new Splitter(compiler, nestedFunction, outermostCompileUnit).split(nestedFunction);
   23.48 -                getLexicalContext().replace(nestedFunction, split);
   23.49 +                lc.replace(nestedFunction, split);
   23.50                  return split;
   23.51              }
   23.52          });
   23.53 @@ -149,13 +148,13 @@
   23.54  
   23.55      private static List<FunctionNode> directChildren(final FunctionNode functionNode) {
   23.56          final List<FunctionNode> dc = new ArrayList<>();
   23.57 -        functionNode.accept(new NodeVisitor() {
   23.58 +        functionNode.accept(new NodeVisitor<LexicalContext>(new LexicalContext()) {
   23.59              @Override
   23.60              public boolean enterFunctionNode(final FunctionNode child) {
   23.61                  if (child == functionNode) {
   23.62                      return true;
   23.63                  }
   23.64 -                if (getLexicalContext().getParentFunction(child) == functionNode) {
   23.65 +                if (lc.getParentFunction(child) == functionNode) {
   23.66                      dc.add(child);
   23.67                  }
   23.68                  return false;
   23.69 @@ -181,7 +180,7 @@
   23.70       * @return new weight for the resulting block.
   23.71       */
   23.72      private Block splitBlock(final Block block, final FunctionNode function) {
   23.73 -        getLexicalContext().setFlag(getLexicalContext().getCurrentFunction(), FunctionNode.IS_SPLIT);
   23.74 +        lc.setFlag(lc.getCurrentFunction(), FunctionNode.IS_SPLIT);
   23.75  
   23.76          final List<Statement> splits = new ArrayList<>();
   23.77          List<Statement> statements = new ArrayList<>();
   23.78 @@ -210,7 +209,7 @@
   23.79              splits.add(createBlockSplitNode(block, function, statements, statementsWeight));
   23.80          }
   23.81  
   23.82 -        return block.setStatements(getLexicalContext(), splits);
   23.83 +        return block.setStatements(lc, splits);
   23.84      }
   23.85  
   23.86      /**
   23.87 @@ -258,7 +257,7 @@
   23.88          // been split already, so weigh again before splitting.
   23.89          long weight = WeighNodes.weigh(block, weightCache);
   23.90          if (weight >= SPLIT_THRESHOLD) {
   23.91 -            newBlock = splitBlock(block, getLexicalContext().getFunction(block));
   23.92 +            newBlock = splitBlock(block, lc.getFunction(block));
   23.93              weight   = WeighNodes.weigh(newBlock, weightCache);
   23.94          }
   23.95          weightCache.put(newBlock, weight);
   23.96 @@ -274,9 +273,9 @@
   23.97              return literal;
   23.98          }
   23.99  
  23.100 -        final FunctionNode functionNode = getLexicalContext().getCurrentFunction();
  23.101 +        final FunctionNode functionNode = lc.getCurrentFunction();
  23.102  
  23.103 -        getLexicalContext().setFlag(functionNode, FunctionNode.IS_SPLIT);
  23.104 +        lc.setFlag(functionNode, FunctionNode.IS_SPLIT);
  23.105  
  23.106          if (literal instanceof ArrayLiteralNode) {
  23.107              final ArrayLiteralNode arrayLiteralNode = (ArrayLiteralNode) literal;