[GR-29435] Provide partial support for testthat 3.0.1.

PullRequest: fastr/2613

Author: Pavel Marek

com.oracle.truffle.r.engine/src/com/oracle/truffle/r/engine/shell/REmbedded.java

@@ -103,11 +103,11 @@ private static void initializeR(String[] args, boolean initMainLoop) {
      * has been fully initialized yet.
      */
     @SuppressWarnings("unused")
-    private static void setParams(boolean quietA, boolean noEcho, boolean interactiveA, boolean verboseA, boolean loadSiteFileA,
+    private static void setParams(boolean quietA, boolean noEchoA, boolean interactiveA, boolean verboseA, boolean loadSiteFileA,
                     boolean loadInitFileA, boolean debugInitFileA, int restoreActionA, int saveActionA, boolean noRenvironA) {
         context.enter();
         RStartParams params = RContext.getInstance().getStartParams();
-        params.setParams(quietA, noEcho, interactiveA, verboseA, loadSiteFileA, loadInitFileA, debugInitFileA, restoreActionA, saveActionA, noRenvironA);
+        params.setParams(quietA, noEchoA, interactiveA, verboseA, loadSiteFileA, loadInitFileA, debugInitFileA, restoreActionA, saveActionA, noRenvironA);
         context.leave();
     }
 

com.oracle.truffle.r.ffi.impl/src/com/oracle/truffle/r/ffi/impl/nodes/MatchNodes.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2021, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -32,15 +32,15 @@
 import com.oracle.truffle.r.runtime.RInternalError;
 import com.oracle.truffle.r.runtime.RRuntime;
 import com.oracle.truffle.r.runtime.data.CharSXPWrapper;
-import com.oracle.truffle.r.runtime.data.RTypes;
 import com.oracle.truffle.r.runtime.data.RStringVector;
+import com.oracle.truffle.r.runtime.data.RTypes;
 
 public final class MatchNodes {
 
     @TypeSystemReference(RTypes.class)
     public abstract static class Match5UpCallNode extends FFIUpCallNode.Arg5 {
         @Specialization
-        Object match(Object x, Object table, int noMatch, Object incomparables, @SuppressWarnings("unused") Object env,
+        Object match(Object table, Object x, int noMatch, Object incomparables, @SuppressWarnings("unused") Object env,
                         @Cached Match5Node match5Node) {
             return match5Node.execute(x, table, noMatch, incomparables);
         }

com.oracle.truffle.r.launcher/src/com/oracle/truffle/r/launcher/RStartParams.java

@@ -132,10 +132,10 @@ public RStartParams(RCmdOptions options, boolean embedded) {
     /**
      * Used for R embedding, allows to alter some of the values.
      */
-    public void setParams(boolean quietA, boolean noEcho, boolean interactiveA, boolean verboseA, boolean loadSiteFileA,
+    public void setParams(boolean quietA, boolean noEchoA, boolean interactiveA, boolean verboseA, boolean loadSiteFileA,
                     boolean loadInitFileA, boolean debugInitFileA, @SuppressWarnings("unused") int restoreActionA, @SuppressWarnings("unused") int saveActionA, boolean noRenvironA) {
         quiet = quietA;
-        this.noEcho = noEcho;
+        noEcho = noEchoA;
         interactive = interactiveA;
         verbose = verboseA;
         loadSiteFile = loadSiteFileA;

com.oracle.truffle.r.nodes.builtin/src/com/oracle/truffle/r/nodes/builtin/base/FileFunctions.java

@@ -35,6 +35,7 @@
 
 import java.io.BufferedInputStream;
 import java.io.BufferedOutputStream;
+import java.io.File;
 import java.io.IOException;
 import java.io.UncheckedIOException;
 import java.nio.file.CopyOption;
@@ -713,7 +714,7 @@ private static RStringVector doListFilesBody(RStringVector vec, String patternSt
                         }
                         file = root.relativize(file);
                         String p = file.getPath();
-                        if (p.startsWith(vecPathString)) {
+                        if (isPathPrefixOf(p, vecPathString)) {
                             p = p.substring(vecPathString.length());
                             if (p.startsWith("/")) {
                                 p = p.substring(1);
@@ -762,6 +763,13 @@ private static RStringVector doListFilesBody(RStringVector vec, String patternSt
             }
         }
 
+        private static boolean isPathPrefixOf(String filePath, String dirPath) {
+            if (!filePath.startsWith(dirPath)) {
+                return false;
+            }
+            return dirPath.contains(File.separator) && filePath.contains(File.separator);
+        }
+
         private static String skipLeadingDotInFilename(String filePath, String fileSeparator) {
             String[] items = filePath.split(Pattern.quote(fileSeparator));
             String baseName = items[items.length - 1];

com.oracle.truffle.r.nodes.builtin/src/com/oracle/truffle/r/nodes/builtin/base/GrepFunctions.java

@@ -255,7 +255,7 @@ protected Object doGrep(String patternArg, RStringVector vector, boolean ignoreC
                 if (!perl) {
                     // TODO case
                     if (!fixed) {
-                        pattern = RegExp.checkPreDefinedClasses(pattern);
+                        pattern = RegExp.transformPatternToGnurCompatible(pattern);
                     }
                     findAllMatches(matches, pattern, vector, fixed, ignoreCase);
                 } else {
@@ -488,7 +488,7 @@ protected RStringVector doSub(String patternArg, String replacementArg, RStringV
                 } else if (perl) {
                     pcre = compilePerlPattern(pattern, ignoreCase);
                 } else {
-                    pattern = RegExp.checkPreDefinedClasses(pattern);
+                    pattern = RegExp.transformPatternToGnurCompatible(pattern);
                 }
                 String preparedReplacement = null;
                 String[] result = new String[len];
@@ -874,7 +874,7 @@ protected Object regexp(RStringVector patternArg, RStringVector vector, boolean
                 }
                 String pattern = patternArg.getDataAt(0);
                 if (!perl && !fixed) {
-                    pattern = RegExp.checkPreDefinedClasses(pattern);
+                    pattern = RegExp.transformPatternToGnurCompatible(pattern);
                 }
                 // TODO: useBytes normally depends on the value of the parameter and (if false) on
                 // whether the string is ASCII
@@ -1115,7 +1115,7 @@ protected Object regexp(RStringVector patternArgIn, RStringVector vector, boolea
                 }
                 RList ret = RDataFactory.createList(vector.getLength());
                 String pattern = patternArg.getDataAt(0);
-                pattern = RegExp.checkPreDefinedClasses(pattern);
+                pattern = RegExp.transformPatternToGnurCompatible(pattern);
                 // TODO: useBytes normally depends on the value of the parameter and (if false) on
                 // whether the string is ASCII
                 boolean useBytes = true;
@@ -1262,7 +1262,7 @@ protected Object regexp(RStringVector patternArg, RStringVector vector, boolean
                 }
                 String pattern = patternArg.getDataAt(0);
                 if (!perl && !fixed) {
-                    pattern = RegExp.checkPreDefinedClasses(pattern);
+                    pattern = RegExp.transformPatternToGnurCompatible(pattern);
                 }
                 // TODO: useBytes normally depends on the value of the parameter and (if false) on
                 // whether the string is ASCII
@@ -1552,7 +1552,7 @@ protected RList split(RStringVector x, RStringVector splitArg, boolean fixed, bo
             na.enable(x);
             for (int i = 0; i < splits.length; i++) {
                 String currentSplit = split.getDataAt(i);
-                splits[i] = fixed || perl ? split.getDataAt(i) : RegExp.checkPreDefinedClasses(split.getDataAt(i));
+                splits[i] = fixed || perl ? split.getDataAt(i) : RegExp.transformPatternToGnurCompatible(split.getDataAt(i));
                 if (perl) {
                     if (!currentSplit.isEmpty()) {
                         pcreSplits[i] = common.compileNode.execute(currentSplit, 0, pcreTables);

com.oracle.truffle.r.nodes.builtin/src/com/oracle/truffle/r/nodes/builtin/base/LocaleFunctions.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2014, 2021, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it

com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/DCF.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014, 2018, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2014, 2021, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -31,6 +31,12 @@
  * Read/write a <a href="http://www.debian.org/doc/debian-policy/ch-controlfields.html">Debian
  * Control File</a>.
  *
+ * Note that for the
+ * <a href="https://cran.r-project.org/doc/manuals/r-release/R-exts.html#The-DESCRIPTION-file"> R
+ * DESCRIPTION file </a> it is not specified whether or not the whitespaces in fields values (for
+ * multiline and continuation fields) should be retained. GNU-R 4.0.3 does retain the whitespaces in
+ * the fields by default, therefore we also retain them.
+ *
  */
 public class DCF {
 
@@ -42,6 +48,9 @@ private void add(String name, String content) {
             fieldMap.put(name, content);
         }
 
+        /**
+         * Note that values of fields may contain white spaces at the beginning or at the end.
+         */
         public LinkedHashMap<String, String> getFields() {
             return fieldMap;
         }
@@ -61,9 +70,13 @@ public static DCF read(String[] lines, Set<String> keepWhiteSet) {
             if (line.startsWith("#")) {
                 continue;
             }
-            final int wsLen = getWhiteSpaceHeadLength(line);
-            if (wsLen > 0) {
-                fieldContent.append('\n').append(line.substring(wsLen));
+            if (isContinuationLine(line)) {
+                assert fieldName != null;
+                if (shouldStripWhiteSpaceOfField(fieldName, keepWhiteSet)) {
+                    fieldContent.append('\n').append(line.trim());
+                } else {
+                    fieldContent.append('\n').append(line);
+                }
             } else {
                 // should start a field, finish off any current one
                 if (fieldName != null) {
@@ -92,14 +105,9 @@ public static DCF read(String[] lines, Set<String> keepWhiteSet) {
                 }
             }
         }
-        // end of the field for sure
         if (fieldName != null) {
-            boolean stripWhite = keepWhiteSet == null || !keepWhiteSet.contains(fieldName);
-            String fieldAsString = fieldContent.toString();
-            if (stripWhite) {
-                fieldAsString = fieldAsString.trim();
-            }
-            fields.add(fieldName, fieldAsString);
+            // Finish the last field
+            fields.add(fieldName, fieldContent.toString());
             result.paragraphs.add(fields);
         }
         return result;
@@ -109,6 +117,16 @@ public List<Fields> getRecords() {
         return paragraphs;
     }
 
+    private static boolean isContinuationLine(String line) {
+        int wsLen = getWhiteSpaceHeadLength(line);
+        return wsLen > 0;
+    }
+
+    private static boolean shouldStripWhiteSpaceOfField(String fieldName, Set<String> keepWhiteSet) {
+        assert fieldName != null;
+        return keepWhiteSet == null || !keepWhiteSet.contains(fieldName);
+    }
+
     private static int getWhiteSpaceHeadLength(String line) {
         int i;
         for (i = 0; i < line.length() && (line.charAt(i) == ' ' || line.charAt(i) == '\t'); i++) {

com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/RLocale.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014, 2018, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2014, 2021, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -154,7 +154,7 @@ public void setLocale(RLocale locale, String value, boolean startup) {
                 l = getLocale(value);
                 if ((c == null && l == null) || (l == null && locale.needsLocale)) {
                     if (startup) {
-                        RContext.getInstance().getConsole().printErrorln("Setting " + locale.name + " failed, using default");
+                        RContext.getInstance().getConsole().printErrorln("Setting " + locale.name + " to " + value + " failed, using default");
                     } else {
                         RError.warning(RError.SHOW_CALLER, Message.OS_REQUEST_LOCALE, value);
                     }

com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/RegExp.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014, 2018, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2014, 2021, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -54,14 +54,27 @@ private enum Predefined {
         }
     }
 
+    /**
+     * Transforms given pattern into a pattern that can be used by the Java regexp library.
+     * 
+     * @param pattern Pattern that can be used directly by GNU-R engine.
+     * @return Pattern that can be used directly by Java regexp library.
+     */
+    public static String transformPatternToGnurCompatible(String pattern) {
+        String transformedPattern = pattern;
+        transformedPattern = checkPreDefinedClasses(transformedPattern);
+        transformedPattern = checkSpacesInQuantifiers(transformedPattern);
+        return transformedPattern;
+    }
+
     /**
      * R defines some short forms of character classes. E.g. {@code [[:alnum:]]} means
      * {@code [0-9A-Za-z]} but independent of locale and character encoding. So we have to translate
      * these for use with Java regexp. TODO handle the complete set and do locale and character
      * encoding
      */
     @TruffleBoundary
-    public static String checkPreDefinedClasses(String pattern) {
+    private static String checkPreDefinedClasses(String pattern) {
         String result = pattern;
         /*
          * this loop replaces "[[]" (illegal in Java regex) with "[\[]", "[\]" with "[\\]" and
@@ -139,4 +152,101 @@ public static String checkPreDefinedClasses(String pattern) {
         }
         return result;
     }
+
+    /**
+     * GNU-R ignores some spaces in quantifiers, e.g., in "{3, }", the space in front of the last
+     * bracket is ignored. In PCRE, this is a valid expression that is, however, not interpreted as
+     * a quantifier. In Java regexp library, this is not a valid expression.
+     * 
+     * @param pattern Pattern, potentially with spaces in quantifiers.
+     * @return Pattern without spaces in quantifiers.
+     */
+    @TruffleBoundary
+    private static String checkSpacesInQuantifiers(String pattern) {
+        boolean escapedOpeningBracket = false;
+        int i = 0;
+        StringBuilder sb = new StringBuilder();
+        while (i < pattern.length()) {
+            char currentChar = pattern.charAt(i);
+            switch (currentChar) {
+                case '{':
+                    if (!escapedOpeningBracket) {
+                        int idxOfClosingBracket = pattern.indexOf("}", i);
+                        if (idxOfClosingBracket == -1) {
+                            // This is a pattern syntax error, just forward the pattern as is.
+                            return pattern;
+                        }
+                        // quantifierContent is without the opening bracket.
+                        String quantifierContent = pattern.substring(i + 1, idxOfClosingBracket);
+                        int idxOfComma = quantifierContent.indexOf(",");
+                        if (idxOfComma == -1) {
+                            return pattern;
+                        }
+                        String quantifierContentBeforeComma = quantifierContent.substring(0, idxOfComma);
+                        String quantifierContentAfterComma = quantifierContent.substring(idxOfComma + 1);
+                        sb.append("{");
+                        sb.append(quantifierContentBeforeComma);
+                        sb.append(",");
+                        if (!quantifierContentAfterComma.isEmpty() && containsOnlyWhiteSpaces(quantifierContentAfterComma)) {
+                            sb.append(removeWhiteSpaces(quantifierContentAfterComma));
+                        } else {
+                            sb.append(quantifierContentAfterComma);
+                        }
+                        sb.append("}");
+                        i += 3 + quantifierContentBeforeComma.length() + quantifierContentAfterComma.length();
+                    } else {
+                        escapedOpeningBracket = false;
+                        sb.append(currentChar);
+                        i++;
+                    }
+                    break;
+                case '\\':
+                    if (i < pattern.length() - 1 && pattern.charAt(i + 1) == '{') {
+                        escapedOpeningBracket = true;
+                    }
+                    sb.append(currentChar);
+                    i++;
+                    break;
+                default:
+                    sb.append(currentChar);
+                    i++;
+                    break;
+            }
+        }
+        return sb.toString();
+    }
+
+    private static boolean containsOnlyWhiteSpaces(String string) {
+        for (int i = 0; i < string.length(); i++) {
+            if (!isWhiteSpace(string.charAt(i))) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    private static int indexOfWhiteSpace(String string) {
+        for (int i = 0; i < string.length(); i++) {
+            if (isWhiteSpace(string.charAt(i))) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    private static boolean isWhiteSpace(char c) {
+        return c == ' ';
+    }
+
+    private static String removeWhiteSpaces(String string) {
+        int idxOfWhiteSpace = indexOfWhiteSpace(string);
+        assert idxOfWhiteSpace != -1;
+        StringBuilder sb = new StringBuilder(string.length());
+        for (int i = 0; i < string.length(); i++) {
+            if (!isWhiteSpace(string.charAt(i))) {
+                sb.append(string.charAt(i));
+            }
+        }
+        return sb.toString();
+    }
 }

com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/nmath/Mach.java

@@ -1,7 +1,7 @@
 /*
  * Copyright (C) 1998 Ross Ihaka
  * Copyright (c) 2000--2014, The R Core Team
- * Copyright (c) 2016, 2018, Oracle and/or its affiliates
+ * Copyright (c) 2016, 2021, Oracle and/or its affiliates
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by