jruby · Sep 29, 2014 · Sep 29, 2014 · Sep 29, 2014 · Sep 29, 2014 · Sep 29, 2014
diff --git a/.gitignore b/.gitignore
@@ -79,11 +79,9 @@ dependency-reduced-pom.xml
 install/updates.xml
 
 # generated ITs
-maven/jruby/src/it/osgi_*equinox*
-maven/jruby/src/it/osgi_*felix-3*
-maven/jruby/src/it/osgi_*knoplerfish
+maven/jruby/src/it/osgi_*
 maven/jruby/src/it/j2ee_wlp
-maven/jruby-complete/src/it/osgi_many_bundles_with_embedded_gems_*
+maven/jruby-complete/src/it/osgi*
 
 # IntelliJ project files
 .idea

diff --git a/.travis.yml b/.travis.yml
@@ -42,6 +42,10 @@ matrix:
       jdk: oraclejdk7
     - env: TARGET='-Pcomplete'
       jdk: oraclejdk8
+    - env: TARGET='-Posgi'
+      jdk: openjdk7
+    - env: TARGET='-Pj2ee'
+      jdk: oraclejdk7
   fast_finish: true
   allow_failures:
     - env: TARGET='-Prake -Dtask=spec:compiler'

diff --git a/BUILDING.md b/BUILDING.md
@@ -188,6 +188,35 @@ The complete CI test suite will take anywhere from 20 to 45 minutes to
 complete, but provides the most accurate indication of the stability of
 your local JRuby source.
 
+### maven integration tests - -Pjruby-complete or -Pmain
+
+maven integration test will use the packed maven artifact to run the tests in a forked maven instance. these maven projects are locatated in
+
+```
+maven/jruby/src/it
+maven/jruby-complete/src/it
+maven/jruby-jars/src/it
+maven/jruby-dist/src/it
+```
+
+to trigger the tests with the build:
+
+```
+mvn -Pmain -Dinvoker.skip=false
+mvn -Pcomplete -Dinvoker.skip=false
+mvn -Pdist -Dinvoker.skip=false
+mvn -Pjruby-jars -Dinvoker.skip=false
+```
+
+to pick a particular test add the name of the directory inside the respective *src/it* folder, like (wildcards are possible):
+
+
+```
+mvn -Pmain -Dinvoker.skip=false -Dinvoker.test=integrity
+mvn -Pmain -Dinvoker.skip=false -Dinvoker.test=j2ee*
+mvn -Pmain -Dinvoker.skip=false -Dinvoker.test=osgi*
+```
+
 Clean Build
 -----------
 
@@ -205,6 +234,12 @@ that everything is rebuilt properly.
 
 NOTE: ```mvn clean``` just cleans the **jruby-core** artifact and the **./lib/jruby.jar** !
 
+clean everything:
+
+```
+mvn -Pclean
+```
+
 Distribution Packages
 ---------------------
 
@@ -240,7 +275,6 @@ mvn -Pjruby-jars
 
 the gem will be in ./maven/jruby-jars/pkg
 
-<<<<<<< HEAD
 ### building ALL packages ###
 
 ```
@@ -257,10 +291,13 @@ jruby -S rmvn -Pclean
 
 ## release ##
 
-first set the new version (on jruby-1_7 branch):
+first set the new version in the file *VERSION* inside the root directory and then
 
 ```
-mvn versions:set -DnewVersion=1.7.5
+rake maven:dump_poms
+```
+or
+```
 rmvn validate -Pall
 ```
 
@@ -279,7 +316,8 @@ mvn clean deploy -Psonatype-oss-release -Prelease
 
 go to oss.sonatype.org and close the deployment which will check if all 'required' files are in place and then finally push the release to maven central and . . . 
 
-# hacking the build system #
+hacking the build system
+------------------------
 
 the build system uses the **ruby-maven** gem and with this the build files are **pom.rb** and **Mavenfile**. the **Mavenfile** are used whenever the module produces a gem and uses the gemspec file for the gem for setting up the POM. otherwise **pom.rb** are used. so any change in the build-system is done in those files !!!!
 
@@ -297,11 +335,14 @@ regular maven uses the the jruby from the installation, i.e. 9000.dev. this also
 
 at some parts there are **inline** plugins in **pom.rb** or **Mavenfile** which will work directly with regular maven where there is a special plugin running those ruby parts. see **./lib/pom.rb**.
 
-### Start development
+### Start a new version
 
-After the release set the new development version:
+After the release set the new development version in *VERSION* and generate the pom.xml files
 
 ```
-mvn versions:set -DnewVersion=1.7.6-SNAPSHOT
+rake maven:dump_poms
+```
+or
+```
 rmvn validate -Pall
 ```
diff --git a/COPYING b/COPYING
@@ -105,6 +105,14 @@ lib/ruby/1.9, and lib/ruby/site_ruby/1.8/rubygems*.
  The "yecht" library is Copyright (c) 2009-2011 Ola Bini, and released
  under the MIT license.
 
+ The Rubinius API implementation in core/src/main/ruby/jruby/truffle/core/rubinius/api
+ and core/src/main/java/org/jruby/truffle/runtime/rubinius is copyright (c) 2011,
+ Evan Phoenix, and released under the 3-clause BSD license.
+
+ The Rubinius core library implementation in core/src/main/ruby/jruby/truffle/core/rubinius/kernel
+ is copyright (c) 2007-2014, Evan Phoenix and contributors, and released under
+ the 3-clause BSD license.
+
 The complete text of the Eclipse Public License is as follows:
 
   Eclipse Public License - v 1.0

diff --git a/core/pom.rb b/core/pom.rb
@@ -259,7 +259,7 @@
   end
 
 
-  [ :dist, :'jruby-jars', :main, :all, :complete, :release, :snapshots ].each do |name|
+  [ :osgi, :dist, :'jruby-jars', :main, :all, :complete, :release, :snapshots ].each do |name|
     profile name do
       plugin :shade do
         execute_goals( 'shade',

diff --git a/core/pom.xml b/core/pom.xml
@@ -555,6 +555,63 @@
     </plugins>
   </build>
   <profiles>
+    <profile>
+      <id>osgi</id>
+      <build>
+        <plugins>
+          <plugin>
+            <artifactId>maven-shade-plugin</artifactId>
+            <executions>
+              <execution>
+                <id>pack jruby-core-noasm.jar</id>
+                <phase>verify</phase>
+                <goals>
+                  <goal>shade</goal>
+                </goals>
+                <configuration>
+                  <shadedArtifactAttached>true</shadedArtifactAttached>
+                  <shadedClassifierName>noasm</shadedClassifierName>
+                  <artifactSet>
+                    <includes>
+                      <include>com.github.jnr:jnr-ffi</include>
+                      <include>org.ow2.asm:*</include>
+                    </includes>
+                  </artifactSet>
+                  <relocations>
+                    <relocation>
+                      <pattern>org.objectweb</pattern>
+                      <shadedPattern>org.jruby.org.objectweb</shadedPattern>
+                    </relocation>
+                  </relocations>
+                </configuration>
+              </execution>
+              <execution>
+                <id>pack jruby-core-complete.jar</id>
+                <phase>verify</phase>
+                <goals>
+                  <goal>shade</goal>
+                </goals>
+                <configuration>
+                  <shadedArtifactAttached>true</shadedArtifactAttached>
+                  <shadedClassifierName>complete</shadedClassifierName>
+                  <relocations>
+                    <relocation>
+                      <pattern>org.objectweb</pattern>
+                      <shadedPattern>org.jruby.org.objectweb</shadedPattern>
+                    </relocation>
+                  </relocations>
+                  <transformers>
+                    <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
+                      <mainClass>org.jruby.Main</mainClass>
+                    </transformer>
+                  </transformers>
+                </configuration>
+              </execution>
+            </executions>
+          </plugin>
+        </plugins>
+      </build>
+    </profile>
     <profile>
       <id>dist</id>
       <build>

diff --git a/core/src/main/java/org/jruby/internal/runtime/methods/InterpretedIRMethod.java b/core/src/main/java/org/jruby/internal/runtime/methods/InterpretedIRMethod.java
@@ -140,7 +140,7 @@ public void ensureInstrsReady() {
         // Prepare method if not yet done so we know if the method has an explicit/implicit call protocol
         if (method.getInstrsForInterpretation() == null) {
             method.prepareForInterpretation(false);
-            this.pushScope = method.getFlags().contains(IRFlags.REQUIRES_DYNSCOPE) || !method.getFlags().contains(IRFlags.DYNSCOPE_ELIMINATED);
+            this.pushScope = !method.getFlags().contains(IRFlags.DYNSCOPE_ELIMINATED);
         }
     }
 

diff --git a/core/src/main/java/org/jruby/ir/IRFlags.java b/core/src/main/java/org/jruby/ir/IRFlags.java
@@ -44,6 +44,7 @@ public enum IRFlags {
     HAS_EXPLICIT_CALL_PROTOCOL,   // contains call protocol instrs.  if so we don't need to manage bindings frame implicitly.
     HAS_LOOPS,                    // has a loop
     HAS_NONLOCAL_RETURNS,         // has a non-local return
+    HAS_OPTIMIZED_TEMPORARY_VARIABLES, // we simplified number of temp vars (before CFG was built). we can only do once.
     HAS_UNUSED_IMPLICIT_BLOCK_ARG,// Is %block implicit block arg unused?
     RECEIVES_CLOSURE_ARG,         // This scope (or parent receives a closure
     RECEIVES_KEYWORD_ARGS,        // receives keyword args
@@ -55,4 +56,5 @@ public enum IRFlags {
     REQUIRES_VISIBILITY,          // callee may read/write caller's visibility
 
     DYNSCOPE_ELIMINATED,          // local var load/stores have been converted to tmp var accesses
+    REUSE_PARENT_DYNSCOPE,        // for clsoures -- reuse parent's dynscope
 }
diff --git a/core/src/main/java/org/jruby/ir/IRScope.java b/core/src/main/java/org/jruby/ir/IRScope.java
@@ -11,6 +11,8 @@
 import org.jruby.ir.passes.CompilerPass;
 import org.jruby.ir.passes.CompilerPassScheduler;
 import org.jruby.ir.passes.DeadCodeElimination;
+import org.jruby.ir.dataflow.analyses.StoreLocalVarPlacementProblem;
+import org.jruby.ir.dataflow.analyses.LiveVariablesProblem;
 import org.jruby.ir.passes.UnboxingPass;
 import org.jruby.ir.persistence.IRReaderDecoder;
 import org.jruby.ir.representations.BasicBlock;
@@ -398,6 +400,14 @@ public boolean isNestedInClosure(IRClosure closure) {
         return false;
     }
 
+    public boolean hasHasOptimizedTemporaryVariables() {
+        return flags.contains(HAS_OPTIMIZED_TEMPORARY_VARIABLES);
+    }
+
+    public void setHasOptimizedTemporaryVariables() {
+        flags.add(HAS_OPTIMIZED_TEMPORARY_VARIABLES);
+    }
+
     public void setHasLoopsFlag() {
         flags.add(HAS_LOOPS);
     }
@@ -451,7 +461,7 @@ public CFG buildCFG() {
     }
 
     protected void setCFG(CFG cfg) {
-       this.cfg = cfg;
+        this.cfg = cfg;
     }
 
     public CFG getCFG() {
@@ -517,19 +527,7 @@ public void setupRescueMap() {
         }
     }
 
-    private void runCompilerPasses(List<CompilerPass> passes) {
-        // SSS FIXME: Why is this again?  Document this weirdness!
-        // Forcibly clear out the shared eval-scope variable allocator each time this method executes
-        initEvalScopeVariableAllocator(true);
-
-        // SSS FIXME: We should configure different optimization levels
-        // and run different kinds of analysis depending on time budget.
-        // Accordingly, we need to set IR levels/states (basic, optimized, etc.)
-        // ENEBO: If we use a MT optimization mechanism we cannot mutate CFG
-        // while another thread is using it.  This may need to happen on a clone()
-        // and we may need to update the method to return the new method.  Also,
-        // if this scope is held in multiple locations how do we update all references?
-
+    private boolean isUnsafeScope() {
         boolean unsafeScope = false;
         if (flags.contains(HAS_END_BLOCKS) || this.isBeginEndBlock()) {
             unsafeScope = true;
@@ -545,12 +543,27 @@ private void runCompilerPasses(List<CompilerPass> passes) {
                 unsafeScope = true;
             }
         }
+        return unsafeScope;
+    }
+
+    private void runCompilerPasses(List<CompilerPass> passes) {
+        // SSS FIXME: Why is this again?  Document this weirdness!
+        // Forcibly clear out the shared eval-scope variable allocator each time this method executes
+        initEvalScopeVariableAllocator(true);
+
+        // SSS FIXME: We should configure different optimization levels
+        // and run different kinds of analysis depending on time budget.
+        // Accordingly, we need to set IR levels/states (basic, optimized, etc.)
+        // ENEBO: If we use a MT optimization mechanism we cannot mutate CFG
+        // while another thread is using it.  This may need to happen on a clone()
+        // and we may need to update the method to return the new method.  Also,
+        // if this scope is held in multiple locations how do we update all references?
 
         // All passes are disabled in scopes where BEGIN and END scopes might
         // screw around with escaped variables. Optimizing for them is not
         // worth the effort. It is simpler to just go fully safe in scopes
         // influenced by their presence.
-        if (unsafeScope) {
+        if (isUnsafeScope()) {
             passes = getManager().getSafePasses(this);
         }
 
@@ -567,17 +580,23 @@ private void runCompilerPasses(List<CompilerPass> passes) {
     }
 
     private void runDeadCodeAndVarLoadStorePasses() {
-        // For methods that don't require a dynamic scope,
+        // For scopes that don't require a dynamic scope,
         // inline-add lvar loads/store to tmp-var loads/stores.
-        if (!flags.contains(HAS_END_BLOCKS) && !flags.contains(REQUIRES_DYNSCOPE)) {
+        if (!isUnsafeScope() && !flags.contains(REQUIRES_DYNSCOPE)) {
             CompilerPass pass;
             pass = new DeadCodeElimination();
             if (pass.previouslyRun(this) == null) {
                 pass.run(this);
             }
+
+            // This will run the simplified version of the pass
+            // that doesn't require dataflow analysis and hence
+            // can run on closures independent of enclosing scopes.
             pass = new AddLocalVarLoadStoreInstructions();
             if (pass.previouslyRun(this) == null) {
-                pass.run(this);
+                ((AddLocalVarLoadStoreInstructions)pass).eliminateLocalVars(this);
+                setDataFlowSolution(StoreLocalVarPlacementProblem.NAME, new StoreLocalVarPlacementProblem());
+                setDataFlowSolution(LiveVariablesProblem.NAME, null);
             }
         }
     }
@@ -730,7 +749,7 @@ public void computeScopeFlags() {
         }
 
         // Compute flags for nested closures (recursively) and set derived flags.
-        for (IRClosure cl : getClosures()) {
+        for (IRClosure cl: getClosures()) {
             cl.computeScopeFlags();
             if (cl.usesEval()) {
                 flags.add(CAN_RECEIVE_BREAKS);
@@ -749,8 +768,8 @@ public void computeScopeFlags() {
             }
         }
 
-        if (!(this instanceof IRMethod)
-            || flags.contains(CAN_RECEIVE_BREAKS)
+        if (flags.contains(CAN_RECEIVE_BREAKS)
+            || flags.contains(HAS_NONLOCAL_RETURNS)
             || flags.contains(CAN_RECEIVE_NONLOCAL_RETURNS)
             || flags.contains(BINDING_HAS_ESCAPED)
                // SSS FIXME: checkArity for keyword args
@@ -1087,6 +1106,7 @@ protected void depends(Object obj) {
                 "up wrong.  Use depends(build()) not depends(build).";
     }
 
+    // SSS FIXME: Why do we have cfg() with this assertion and a getCFG() without an assertion??
     public CFG cfg() {
         assert cfg != null: "Trying to access build before build started";
         return cfg;

diff --git a/core/src/main/java/org/jruby/ir/IRScriptBody.java b/core/src/main/java/org/jruby/ir/IRScriptBody.java
@@ -104,7 +104,9 @@ public IRubyObject interpret(ThreadContext context, IRubyObject self) {
         IRubyObject retVal;
 
         scope.setModule(currModule);
-        context.preMethodScopeOnly(currModule, scope);
+        if (!this.flags.contains(IRFlags.DYNSCOPE_ELIMINATED)) {
+            context.preMethodScopeOnly(currModule, scope);
+        }
         context.setCurrentVisibility(Visibility.PRIVATE);
 
         try {
@@ -116,7 +118,9 @@ public IRubyObject interpret(ThreadContext context, IRubyObject self) {
         } catch (IRBreakJump bj) {
             throw IRException.BREAK_LocalJumpError.getException(context.runtime);
         } finally {
-            context.popScope();
+            if (!this.flags.contains(IRFlags.DYNSCOPE_ELIMINATED)) {
+                context.popScope();
+            }
         }
 
         return retVal;