Merge branch 'master' into truffle-head

jruby · Jun 5, 2015 · 2d0c3bb · 2d0c3bb
2 parents 798cc1b + 49e9fb2
commit 2d0c3bb
Showing 90 changed files with 5,845 additions and 5,453 deletions.
diff --git a/core/src/main/java/org/jruby/RubyEnumerator.java b/core/src/main/java/org/jruby/RubyEnumerator.java
@@ -297,6 +297,10 @@ public IRubyObject dup() {
      */
     @JRubyMethod
     public IRubyObject each(ThreadContext context, Block block) {
+        if (!block.isGiven()) {
+            return this;
+        }
+
         return object.callMethod(context, method, methodArgs, block);
     }
 

diff --git a/core/src/main/java/org/jruby/RubyModule.java b/core/src/main/java/org/jruby/RubyModule.java
@@ -1597,9 +1597,7 @@ private void addAccessor(ThreadContext context, String internedName, Visibility
 
         final Ruby runtime = context.runtime;
 
-        if (visibility == PRIVATE) {
-            runtime.getWarnings().warn(ID.PRIVATE_ACCESSOR, "private attribute?");
-        } else if (visibility == MODULE_FUNCTION) {
+        if (visibility == MODULE_FUNCTION) {
             runtime.getWarnings().warn(ID.ACCESSOR_MODULE_FUNCTION, "attribute accessor as module_function");
             visibility = PRIVATE;
         }

diff --git a/core/src/main/java/org/jruby/common/IRubyWarnings.java b/core/src/main/java/org/jruby/common/IRubyWarnings.java
@@ -73,7 +73,6 @@ public enum ID {
         NOT_IMPLEMENTED,
         OBSOLETE_ARGUMENT,
         PARENTHISE_ARGUMENTS,
-        PRIVATE_ACCESSOR,
         PROXY_EXTENDED_LATE,
         STATEMENT_NOT_REACHED, 
         LITERAL_IN_CONDITIONAL_RANGE,

diff --git a/core/src/main/java/org/jruby/compiler/JITCompiler.java b/core/src/main/java/org/jruby/compiler/JITCompiler.java
@@ -38,6 +38,7 @@
 import org.jruby.internal.runtime.methods.CompiledIRMethod;
 import org.jruby.internal.runtime.methods.MixedModeIRMethod;
 import org.jruby.ir.IRMethod;
+import org.jruby.ir.interpreter.InterpreterContext;
 import org.jruby.ir.targets.JVMVisitor;
 import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
@@ -363,7 +364,13 @@ protected void compile() {
             // Time the compilation
             long start = System.nanoTime();
 
-            method.ensureInstrsReady();
+            InterpreterContext ic = method.ensureInstrsReady();
+
+            int insnCount = ic.getInstructions().length;
+            if (insnCount > Options.JIT_MAXSIZE.load()) {
+                // methods with more than our limit of basic blocks are likely too large to JIT, so bail out
+                throw new NotCompilableException("Could not compile " + method + "; instruction count " + insnCount + " exceeds threshold of " + Options.JIT_MAXSIZE.load());
+            }
 
             // This may not be ok since we'll end up running passes specific to JIT
             // CON FIXME: Really should clone scope before passes in any case

diff --git a/core/src/main/java/org/jruby/lexer/yacc/RubyLexer.java b/core/src/main/java/org/jruby/lexer/yacc/RubyLexer.java
@@ -210,7 +210,7 @@ public enum Keyword {
         ELSIF ("elsif", Tokens.kELSIF, Tokens.kELSIF, LexState.EXPR_BEG),
         DEF ("def", Tokens.kDEF, Tokens.kDEF, LexState.EXPR_FNAME),
         RESCUE ("rescue", Tokens.kRESCUE, Tokens.kRESCUE_MOD, LexState.EXPR_MID),
-        NOT ("not", Tokens.kNOT, Tokens.kNOT, LexState.EXPR_BEG),
+        NOT ("not", Tokens.kNOT, Tokens.kNOT, LexState.EXPR_ARG),
         THEN ("then", Tokens.kTHEN, Tokens.kTHEN, LexState.EXPR_BEG),
         YIELD ("yield", Tokens.kYIELD, Tokens.kYIELD, LexState.EXPR_ARG),
         FOR ("for", Tokens.kFOR, Tokens.kFOR, LexState.EXPR_BEG),
@@ -744,6 +744,14 @@ private boolean isSpaceArg(int c, boolean spaceSeen) {
         return isARG() && spaceSeen && !Character.isWhitespace(c);
     }
 
+    private boolean isLabelSuffix() {
+        return peek(':') && !peek(':', 1);
+    }
+
+    private boolean isAfterOperator() {
+        return lex_state == LexState.EXPR_FNAME || lex_state == LexState.EXPR_DOT;
+    }
+
     private void determineExpressionState() {
         switch (lex_state) {
         case EXPR_FNAME: case EXPR_DOT:
@@ -1229,6 +1237,7 @@ private void printToken(int token) {
             case Tokens.tLAMBEG: System.err.print("tLAMBEG,"); break;
             case Tokens.tRPAREN: System.err.print("tRPAREN,"); break;
             case Tokens.tLABEL: System.err.print("tLABEL("+ value() +":),"); break;
+            case Tokens.tLABEL_END: System.err.print("tLABEL_END"); break;
             case '\n': System.err.println("NL"); break;
             case EOF: System.out.println("EOF"); break;
             case Tokens.tDSTAR: System.err.print("tDSTAR"); break;
@@ -1260,18 +1269,15 @@ private int yylex() throws IOException {
 
             if (tok == Tokens.tSTRING_END && (yaccValue.equals("\"") || yaccValue.equals("'"))) {
                 if (((lex_state == LexState.EXPR_BEG || lex_state == LexState.EXPR_ENDFN) && !conditionState.isInState() ||
-                        isARG()) && peek(':')) {
-                    int c1 = nextc();
-                    if (peek(':')) { // "mod"::SOMETHING (hack MRI does not do this)
-                        pushback(c1);
-                    } else {
-                        nextc();
-                        tok = Tokens.tLABEL_END;
-                    }
+                        isARG()) && isLabelSuffix()) {
+                    nextc();
+                    tok = Tokens.tLABEL_END;
+                    setState(LexState.EXPR_LABELARG);
+                    lex_strterm = null;
                 }
             }
 
-            if (tok == Tokens.tSTRING_END || tok == Tokens.tREGEXP_END || tok == Tokens.tLABEL_END) {
+            if (tok == Tokens.tSTRING_END || tok == Tokens.tREGEXP_END) {
                 lex_strterm = null;
                 setState(LexState.EXPR_END);
             }
@@ -1691,8 +1697,6 @@ private int comma(int c) throws IOException {
     }
 
     private int doKeyword(LexState state) {
-        commandStart = true;
-
         if (leftParenBegin > 0 && leftParenBegin == parenNest) {
             leftParenBegin = 0;
             parenNest--;
@@ -1951,24 +1955,23 @@ private int identifier(int c, boolean commandState) throws IOException {
 
             if (keyword != null) {
                 LexState state = lex_state; // Save state at time keyword is encountered
+                setState(keyword.state);
 
-                if (keyword == Keyword.NOT) {
-                    setState(LexState.EXPR_ARG);
-                } else {
-                    setState(keyword.state);
-                }
                 if (state == LexState.EXPR_FNAME) {
                     yaccValue = keyword.name;
+                    return keyword.id0;
                 } else {
                     yaccValue = getPosition();
-                    if (keyword.id0 == Tokens.kDO) return doKeyword(state);
                 }
 
-                if (state == LexState.EXPR_BEG || state == LexState.EXPR_VALUE) return keyword.id0;
-
-                if (keyword.id0 != keyword.id1) setState(LexState.EXPR_BEG);
+                if (keyword.id0 == Tokens.kDO) return doKeyword(state);
 
-                return keyword.id1;
+                if (state == LexState.EXPR_BEG || state == LexState.EXPR_VALUE || state == LexState.EXPR_LABELARG) {
+                    return keyword.id0;
+                } else {
+                    if (keyword.id0 != keyword.id1) lex_state = LexState.EXPR_BEG;
+                    return keyword.id1;
+                }
             }
         }
 
@@ -2044,20 +2047,14 @@ private int leftCurly() {
     }
 
     private int leftParen(boolean spaceSeen) throws IOException {
-        int result = Tokens.tLPAREN2;
+        int result;
+
         if (isBEG()) {
             result = Tokens.tLPAREN;
-        } else if (spaceSeen) {
-            // ENEBO: 1.9 is IS_ARG, but we need to break apart for 1.8 support.
-            if (lex_state == LexState.EXPR_CMDARG) {
-                result = Tokens.tLPAREN_ARG;
-            } else if (lex_state == LexState.EXPR_ARG) {
-                result = Tokens.tLPAREN_ARG;
-            }
-
-            if (token == Tokens.tLAMBDA) {
-                result = Tokens.tLPAREN2;
-            }
+        } else if (isSpaceArg('(', spaceSeen)) {
+            result = Tokens.tLPAREN_ARG;
+        } else {
+            result = Tokens.tLPAREN2;
         }
 
         parenNest++;
@@ -2126,7 +2123,7 @@ private int minus(boolean spaceSeen) throws IOException {
             return Tokens.tOP_ASGN;
         }
         if (c == '>') {
-            setState(LexState.EXPR_ARG);
+            setState(LexState.EXPR_ENDFN);
             yaccValue = "->";
             return Tokens.tLAMBDA;
         }
@@ -2197,7 +2194,7 @@ private int pipe() throws IOException {
 
     private int plus(boolean spaceSeen) throws IOException {
         int c = nextc();
-        if (lex_state == LexState.EXPR_FNAME || lex_state == LexState.EXPR_DOT) {
+        if (isAfterOperator()) {
             setState(LexState.EXPR_ARG);
             if (c == '@') {
                 yaccValue = "+@";
@@ -2336,7 +2333,7 @@ private int rightCurly() {
         setState(LexState.EXPR_ENDARG);
         yaccValue = "}";
         //System.out.println("braceNest: " + braceNest);
-        int tok = /*braceNest != 0 ? Tokens.tSTRING_DEND : */ Tokens.tRCURLY;
+        int tok = braceNest == 0 ? Tokens.tSTRING_DEND : Tokens.tRCURLY;
         braceNest--;
         return tok;
     }

diff --git a/core/src/main/java/org/jruby/lexer/yacc/StringTerm.java b/core/src/main/java/org/jruby/lexer/yacc/StringTerm.java
@@ -136,6 +136,7 @@ private int parsePeekVariableName(RubyLexer lexer) throws IOException {
             case '{':
                 //lexer.setBraceNest(lexer.getBraceNest() + 1);
                 lexer.setValue("#" + (char) c);
+                lexer.commandStart = true;
                 return Tokens.tSTRING_DBEG;
             default:
                 // We did not find significant char after # so push it back to