[GR-30714] [GR-38806] Get rid of interpreter-only warning.

PullRequest: fastr/2680

Author: Pavel Marek

ci.jsonnet

@@ -1 +1 @@
-{ overlay : '1c0e7b71c8d6a180de84d711b558db84f7253852' }
+{ overlay : '5eba2d1cff5b42403dee3128c8450e395817a2ae' }

com.oracle.truffle.r.native/run/R.sh

@@ -46,4 +46,4 @@ else
     mx=`which mx`
 fi
 
-exec $mx -J-Dpolyglot.engine.WarnInterpreterOnly=false --no-warning --primary-suite-path $PRIMARY_PATH $MX_R_GLOBAL_ARGS R $FASTR_INTERNAL_ARGS $MX_R_CMD_ARGS "$@"
+exec $mx --no-warning --primary-suite-path $PRIMARY_PATH $MX_R_GLOBAL_ARGS R $FASTR_INTERNAL_ARGS $MX_R_CMD_ARGS "$@"

com.oracle.truffle.r.native/run/Rscript_exec.sh

@@ -44,4 +44,4 @@ else
     mx=`which mx`
 fi
 
-exec $mx -J-Dpolyglot.engine.WarnInterpreterOnly=false --no-warning --primary-suite-path $PRIMARY_PATH $MX_R_GLOBAL_ARGS Rscript $FASTR_INTERNAL_ARGS $MX_R_CMD_ARGS "$@"
+exec $mx --no-warning --primary-suite-path $PRIMARY_PATH $MX_R_GLOBAL_ARGS Rscript $FASTR_INTERNAL_ARGS $MX_R_CMD_ARGS "$@"

com.oracle.truffle.r.test.packages/pkgtest/__init__.py

@@ -22,8 +22,13 @@
 #
 
 import logging
+from typing import List, Optional, Tuple, Set
 
-def fuzzy_compare(gnur_content, fastr_content, gnur_filename, fastr_filename, custom_filters=None, dump_preprocessed=False):
+from pkgtest.output_filter import ContentFilter
+
+
+def fuzzy_compare(gnur_content: List[str], fastr_content: List[str], gnur_filename: str, fastr_filename: str,
+                  custom_filters: List[ContentFilter]=(), dump_preprocessed=False) -> Tuple[int, int, int]:
     """
     Compares the test output of GnuR and FastR by ignoring implementation-specific differences like header, error,
     and warning messages.
@@ -33,8 +38,8 @@ def fuzzy_compare(gnur_content, fastr_content, gnur_filename, fastr_filename, cu
     output, respectively.
     """
     logging.debug("Using custom filters:\n" + str(custom_filters))
-    gnur_content = _preprocess_content(gnur_content, custom_filters)
-    fastr_content = _preprocess_content(fastr_content, custom_filters)
+    gnur_content: List[str] = _preprocess_content(gnur_content, custom_filters)
+    fastr_content: List[str] = _preprocess_content(fastr_content, custom_filters)
     if dump_preprocessed:
         with open(gnur_filename + '.preprocessed', 'w') as f:
             f.writelines(gnur_content)
@@ -58,8 +63,8 @@ def fuzzy_compare(gnur_content, fastr_content, gnur_filename, fastr_filename, cu
     overall_result = 0
     # the local result, i.e., for the current statement
     result = 0
-    statements_passed = set()
-    statements_failed = set()
+    statements_passed: Set[int] = set()
+    statements_failed: Set[int] = set()
 
     # the first line must start with the prompt, so capture it
     gnur_prompt = _capture_prompt(gnur_content, gnur_i)
@@ -82,7 +87,7 @@ def fuzzy_compare(gnur_content, fastr_content, gnur_filename, fastr_filename, cu
         sync = False
         if gnur_line != fastr_line:
             if fastr_line.startswith('Warning') and 'FastR does not support graphics package' in fastr_content[
-                fastr_i + 1]:
+                    fastr_i + 1]:
                 # ignore warning about FastR not supporting the graphics package
                 fastr_i = fastr_i + 2
                 if fastr_content[fastr_i].startswith('NULL') and not gnur_line.startswith('NULL'):
@@ -189,7 +194,7 @@ def fuzzy_compare(gnur_content, fastr_content, gnur_filename, fastr_filename, cu
     return overall_result, len(statements_passed), len(statements_failed)
 
 
-def _get_next_line(prompt, content, content_len, line_idx):
+def _get_next_line(prompt: Optional[str], content: List[str], content_len: int, line_idx: int) -> Tuple[Optional[str], int]:
     i = line_idx
     while i < content_len:
         line = content[i]
@@ -202,20 +207,21 @@ def _get_next_line(prompt, content, content_len, line_idx):
     return None, i
 
 
-def _ignore_whitespace(gnur_line, fastr_line):
+def _ignore_whitespace(gnur_line: str, fastr_line: str) -> bool:
     translate_table = {ord(' '): None, ord('\t'): None}
     return gnur_line.translate(translate_table) == fastr_line.translate(translate_table)
 
 
-def _capture_prompt(lines, idx):
+def _capture_prompt(lines: List[str], idx: int) -> Optional[str]:
     # The prompt can be anything, so it is hard to determine it in general.
     # We will therefore just consider the default prompt.
     default_prompt = "> "
     if idx < len(lines) and lines[idx].startswith(default_prompt):
         return default_prompt
     return None
 
-def _find_start(content):
+
+def _find_start(content: List[str]) -> Optional[int]:
     marker = "Type 'q()' to quit R."
     for i in range(len(content)):
         line = content[i]
@@ -230,7 +236,7 @@ def _find_start(content):
     return None
 
 
-def _find_end(content):
+def _find_end(content: List[str]) -> int:
     marker = "Time elapsed:"
     for i in range(len(content)):
         line = content[i]
@@ -240,7 +246,7 @@ def _find_end(content):
     return len(content)
 
 
-def _find_line(gnur_line, fastr_content, fastr_i):
+def _find_line(gnur_line: str, fastr_content: List[str], fastr_i: int) -> int:
     '''
     Search forward in fastr_content from fastr_i searching for a match with gnur_line.
     Do not match empty lines!
@@ -254,14 +260,13 @@ def _find_line(gnur_line, fastr_content, fastr_i):
         fastr_i = fastr_i + 1
     return -1
 
-def _is_ignored_function(fun_name, gnur_content, gnur_stmt, fastr_content, fastr_stmt):
+
+def _is_ignored_function(fun_name: str, gnur_content: List[str], gnur_stmt: int, fastr_content: List[str], fastr_stmt: int) -> bool:
     return gnur_stmt != -1 and fun_name in gnur_content[gnur_stmt] and fastr_stmt != -1 and fun_name in fastr_content[
         fastr_stmt]
 
 
-
-
-def _is_statement_begin(captured_prompt, line):
+def _is_statement_begin(captured_prompt: Optional[str], line: Optional[str]) -> bool:
     if captured_prompt is None:
         return False
     if line is not None:
@@ -270,7 +275,7 @@ def _is_statement_begin(captured_prompt, line):
     return False
 
 
-def _preprocess_content(output, custom_filters):
+def _preprocess_content(output: List[str], custom_filters: List[ContentFilter]) -> List[str]:
     # load file with replacement actions
     if custom_filters:
         for f in custom_filters:

com.oracle.truffle.r.test.packages/pkgtest/fuzzy_compare.py

@@ -23,6 +23,7 @@
 
 import re
 import logging
+from typing import List, Callable
 
 
 class ContentFilter:
@@ -33,15 +34,15 @@ class ContentFilter:
     remove_before = 0
     remove_after = 0
 
-    def __init__(self, pkg_pattern, action, args, remove_before=0, remove_after=0):
+    def __init__(self, pkg_pattern: str, action: str, args: List[str], remove_before=0, remove_after=0):
         self.pkg_pattern = pkg_pattern
         self.pkg_prog = re.compile(pkg_pattern)
         self.action = action
         self.args = args
         self.remove_before = remove_before
         self.remove_after = remove_after
 
-    def _apply_to_lines(self, content, action):
+    def _apply_to_lines(self, content: List[str], action: Callable[[str], str]) -> List[str]:
         if action is not None:
             idx = 0
             while idx < len(content):
@@ -55,7 +56,7 @@ def _apply_to_lines(self, content, action):
                 idx += 1
         return content
 
-    def apply(self, content):
+    def apply(self, content: List[str]) -> List[str]:
         filter_action = None
         if self.action == "r":
             filter_action = lambda l: l.replace(self.args[0], self.args[1])
@@ -67,23 +68,23 @@ def apply(self, content):
             filter_action = lambda l: "" if self.args[0] in l else l
         elif self.action == "s":
             class SubstituteAction:
-                def __init__(self, pattern, repl):
+                def __init__(self, pattern: str, repl: str):
                     self.compiled_regex = re.compile(pattern)
                     self.repl = repl
 
-                def __call__(self, l):
+                def __call__(self, l: str) -> str:
                     return re.sub(self.compiled_regex, self.repl, l)
 
             filter_action = SubstituteAction(self.args[0], self.args[1])
         return self._apply_to_lines(content, filter_action)
 
-    def applies_to_pkg(self, pkg_name):
+    def applies_to_pkg(self, pkg_name: str) -> bool:
         if pkg_name is None:
             return True
         else:
-            return self.pkg_prog.match(pkg_name)
+            return self.pkg_prog.match(pkg_name) is not None
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         fmt_str = "{!s} => {!s}"
         fmt_args = [self.pkg_pattern, self.action]
         for arg in self.args:
@@ -96,9 +97,9 @@ class InvalidFilterException(Exception):
     pass
 
 
-def load_filter_file(file_path):
+def load_filter_file(file_path: str) -> List[ContentFilter]:
     from os.path import isfile
-    filters = []
+    filters: List[ContentFilter] = []
     if isfile(file_path):
         with open(file_path) as f:
             for linenr, line in enumerate(f.readlines()):
@@ -111,22 +112,22 @@ def load_filter_file(file_path):
     return filters
 
 
-def _select_filters(filters, pkg):
+def _select_filters(filters: List[ContentFilter], pkg: str) -> List[ContentFilter]:
     pkg_filters = []
     for f in filters:
         if f.applies_to_pkg(pkg):
             pkg_filters.append(f)
     return pkg_filters
 
 
-def _parse_filter(line):
+def _parse_filter(line: str) -> ContentFilter:
     arrow_idx = line.find("=>")
     if arrow_idx < 0:
         raise InvalidFilterException("cannot find separator '=>'")
     pkg_pattern = line[:arrow_idx].strip()
     action_str = line[arrow_idx + 2:].strip()
     action = action_str[0]
-    args = []
+    args: List[str] = []
     remove_before = 0
     remove_after = 0
     if action == "d" or action == "D":
@@ -156,5 +157,5 @@ def _parse_filter(line):
     return ContentFilter(pkg_pattern, action, args, remove_before, remove_after)
 
 
-def select_filters_for_package(filter_file, pkg):
+def select_filters_for_package(filter_file: str, pkg: str) -> List[ContentFilter]:
     return _select_filters(load_filter_file(filter_file), pkg)

com.oracle.truffle.r.test.packages/pkgtest/output_filter.py

@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
+# Copyright (c) 2019, 2022, 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
@@ -24,15 +24,17 @@
 import logging
 from threading import Thread
 from threading import Lock
+from typing import List, Tuple, Optional, Any, Dict, Callable
+
 import time, signal, errno, sys, os, subprocess
 
 from .util import abort
 
 ERROR_TIMEOUT = 0x700000000 # not 32 bits
-_currentSubprocesses = []
+_currentSubprocesses: List[Tuple[subprocess.Popen, List[str]]] = []
 
 
-def get_os():
+def get_os() -> str:
     """
     Get a canonical form of sys.platform.
     """
@@ -52,14 +54,14 @@ def get_os():
         abort(1, 'Unknown operating system ' + sys.platform)
 
 
-def _addSubprocess(p, args):
+def _addSubprocess(p: subprocess.Popen, args: List[str]) -> Tuple[subprocess.Popen, List[str]]:
     entry = (p, args)
     logging.debug('[{}: started subprocess {}: {}]'.format(os.getpid(), p.pid, args))
     _currentSubprocesses.append(entry)
     return entry
 
 
-def _removeSubprocess(entry):
+def _removeSubprocess(entry: Tuple[subprocess.Popen, List[str]]) -> None:
     if entry and entry in _currentSubprocesses:
         try:
             logging.debug('[{}: removing subprocess {}: {}]'.format(os.getpid(), entry[0], entry[1]))
@@ -68,7 +70,7 @@ def _removeSubprocess(entry):
             pass
 
 
-def waitOn(p):
+def waitOn(p: subprocess.Popen) -> int:
     if get_os() == 'windows':
         # on windows use a poll loop, otherwise signal does not get handled
         retcode = None
@@ -80,7 +82,7 @@ def waitOn(p):
     return retcode
 
 
-def _kill_process(pid, sig):
+def _kill_process(pid: int, sig: int) -> bool:
     """
     Sends the signal `sig` to the process identified by `pid`. If `pid` is a process group
     leader, then signal is sent to the process group id.
@@ -98,8 +100,8 @@ def _kill_process(pid, sig):
         return False
 
 
-def _waitWithTimeout(process, args, timeout, nonZeroIsFatal=True):
-    def _waitpid(pid):
+def _waitWithTimeout(process: subprocess.Popen, args: List[str], timeout: int, nonZeroIsFatal=True) -> int:
+    def _waitpid(pid: int) -> Tuple[int, int]:
         while True:
             try:
                 return os.waitpid(pid, os.WNOHANG)
@@ -136,7 +138,13 @@ def _returncode(status):
         time.sleep(delay)
 
 
-def pkgtest_run(args, nonZeroIsFatal=True, out=None, err=None, cwd=None, timeout=None, env=None, **kwargs):
+def pkgtest_run(args: List[str], nonZeroIsFatal=True,
+                out: Optional[Callable[[str], None]]=None,
+                err: Optional[Callable[[str], None]]=None,
+                cwd: Optional[str]=None,
+                timeout: Optional[int]=None,
+                env: Optional[Dict[str, str]]=None,
+                **kwargs) -> int:
     """
     Imported from MX.
     Run a command in a subprocess, wait for it to complete and return the exit status of the process.
@@ -158,11 +166,11 @@ def pkgtest_run(args, nonZeroIsFatal=True, out=None, err=None, cwd=None, timeout
     else:
         msg = "Environment:\n"
         in_os = set(os.environ) - set(env)
-        if (len(in_os) > 0):
+        if len(in_os) > 0:
             msg = '  environment variables in OS environ but not in env:\n'
             msg += '\n'.join(['      ' + key + '=' + os.environ[key] for key in list(in_os)])
         in_env = set(env) - set(os.environ)
-        if (len(in_env) > 0):
+        if len(in_env) > 0:
             msg += '  environment variables in env but not in OS environ:\n'
             msg += '\n'.join(['      ' + key + '=' + env[key] for key in list(in_env)])
         logging.debug(msg)