Adding upstream version 86.0.1.upstream/86.0.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 839 insertions, 0 deletions

diff --git a/js/src/tests/test262-update.py b/js/src/tests/test262-update.py
new file mode 100755
index 0000000000..548f64d417
--- /dev/null
+++ b/js/src/tests/test262-update.py
@@ -0,0 +1,839 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+from __future__ import print_function
+
+import contextlib
+import io
+import os
+import tempfile
+import shutil
+import sys
+
+from functools import partial
+from itertools import chain
+from operator import itemgetter
+
+# Skip all tests which use features not supported in SpiderMonkey.
+UNSUPPORTED_FEATURES = set(
+    [
+        "tail-call-optimization",
+        "regexp-match-indices",
+        "Intl.DateTimeFormat-quarter",
+        "Intl.Segmenter",
+        "Atomics.waitAsync",
+        "legacy-regexp",
+        "arbitrary-module-namespace-names",
+    ]
+)
+FEATURE_CHECK_NEEDED = {
+    "Atomics": "!this.hasOwnProperty('Atomics')",
+    "FinalizationRegistry": "!this.hasOwnProperty('FinalizationRegistry')",
+    "SharedArrayBuffer": "!this.hasOwnProperty('SharedArrayBuffer')",
+    "WeakRef": "!this.hasOwnProperty('WeakRef')",
+    "Array.prototype.at": "!Array.prototype.at",
+    "String.prototype.at": "!String.prototype.at",
+    "TypedArray.prototype.at": "!Int32Array.prototype.at",
+}
+RELEASE_OR_BETA = set(
+    [
+        "Intl.DateTimeFormat-dayPeriod",
+        "Intl.DateTimeFormat-formatRange",
+    ]
+)
+SHELL_OPTIONS = {
+    "class-fields-private": "--enable-private-fields",
+    "class-static-fields-private": "--enable-private-fields",
+    "class-methods-private": "--enable-private-methods",
+    "class-static-methods-private": "--enable-private-methods",
+    "top-level-await": "--enable-top-level-await",
+}
+
+
+@contextlib.contextmanager
+def TemporaryDirectory():
+    tmpDir = tempfile.mkdtemp()
+    try:
+        yield tmpDir
+    finally:
+        shutil.rmtree(tmpDir)
+
+
+def loadTest262Parser(test262Dir):
+    """
+    Loads the test262 test record parser.
+    """
+    import imp
+
+    fileObj = None
+    try:
+        moduleName = "parseTestRecord"
+        packagingDir = os.path.join(test262Dir, "tools", "packaging")
+        (fileObj, pathName, description) = imp.find_module(moduleName, [packagingDir])
+        return imp.load_module(moduleName, fileObj, pathName, description)
+    finally:
+        if fileObj:
+            fileObj.close()
+
+
+def tryParseTestFile(test262parser, source, testName):
+    """
+    Returns the result of test262parser.parseTestRecord() or None if a parser
+    error occured.
+
+    See <https://github.com/tc39/test262/blob/main/INTERPRETING.md> for an
+    overview of the returned test attributes.
+    """
+    try:
+        return test262parser.parseTestRecord(source, testName)
+    except Exception as err:
+        print("Error '%s' in file: %s" % (err, testName), file=sys.stderr)
+        print("Please report this error to the test262 GitHub repository!")
+        return None
+
+
+def createRefTestEntry(options, skip, skipIf, error, isModule, isAsync):
+    """
+    Returns the |reftest| tuple (terms, comments) from the input arguments. Or a
+    tuple of empty strings if no reftest entry is required.
+    """
+
+    terms = []
+    comments = []
+
+    if options:
+        terms.extend(options)
+
+    if skip:
+        terms.append("skip")
+        comments.extend(skip)
+
+    if skipIf:
+        terms.append("skip-if(" + "||".join([cond for (cond, _) in skipIf]) + ")")
+        comments.extend([comment for (_, comment) in skipIf])
+
+    if error:
+        terms.append("error:" + error)
+
+    if isModule:
+        terms.append("module")
+
+    if isAsync:
+        terms.append("async")
+
+    return (" ".join(terms), ", ".join(comments))
+
+
+def createRefTestLine(terms, comments):
+    """
+    Creates the |reftest| line using the given terms and comments.
+    """
+
+    refTest = terms
+    if comments:
+        refTest += " -- " + comments
+    return refTest
+
+
+def createSource(testSource, refTest, prologue, epilogue):
+    """
+    Returns the post-processed source for |testSource|.
+    """
+
+    source = []
+
+    # Add the |reftest| line.
+    if refTest:
+        source.append(b"// |reftest| " + refTest.encode("utf-8"))
+
+    # Prepend any directives if present.
+    if prologue:
+        source.append(prologue.encode("utf-8"))
+
+    source.append(testSource)
+
+    # Append the test epilogue, i.e. the call to "reportCompare".
+    # TODO: Does this conflict with raw tests?
+    if epilogue:
+        source.append(epilogue.encode("utf-8"))
+        source.append(b"")
+
+    return b"\n".join(source)
+
+
+def writeTestFile(test262OutDir, testFileName, source):
+    """
+    Writes the test source to |test262OutDir|.
+    """
+
+    with io.open(os.path.join(test262OutDir, testFileName), "wb") as output:
+        output.write(source)
+
+
+def addSuffixToFileName(fileName, suffix):
+    (filePath, ext) = os.path.splitext(fileName)
+    return filePath + suffix + ext
+
+
+def writeShellAndBrowserFiles(
+    test262OutDir, harnessDir, includesMap, localIncludesMap, relPath
+):
+    """
+    Generate the shell.js and browser.js files for the test harness.
+    """
+
+    # Find all includes from parent directories.
+    def findParentIncludes():
+        parentIncludes = set()
+        current = relPath
+        while current:
+            (parent, child) = os.path.split(current)
+            if parent in includesMap:
+                parentIncludes.update(includesMap[parent])
+            current = parent
+        return parentIncludes
+
+    # Find all includes, skipping includes already present in parent directories.
+    def findIncludes():
+        parentIncludes = findParentIncludes()
+        for include in includesMap[relPath]:
+            if include not in parentIncludes:
+                yield include
+
+    def readIncludeFile(filePath):
+        with io.open(filePath, "rb") as includeFile:
+            return b"// file: %s\n%s" % (
+                os.path.basename(filePath).encode("utf-8"),
+                includeFile.read(),
+            )
+
+    localIncludes = localIncludesMap[relPath] if relPath in localIncludesMap else []
+
+    # Concatenate all includes files.
+    includeSource = b"\n".join(
+        map(
+            readIncludeFile,
+            chain(
+                # The requested include files.
+                map(partial(os.path.join, harnessDir), sorted(findIncludes())),
+                # And additional local include files.
+                map(partial(os.path.join, os.getcwd()), sorted(localIncludes)),
+            ),
+        )
+    )
+
+    # Write the concatenated include sources to shell.js.
+    with io.open(os.path.join(test262OutDir, relPath, "shell.js"), "wb") as shellFile:
+        if includeSource:
+            shellFile.write(b"// GENERATED, DO NOT EDIT\n")
+            shellFile.write(includeSource)
+
+    # The browser.js file is always empty for test262 tests.
+    with io.open(
+        os.path.join(test262OutDir, relPath, "browser.js"), "wb"
+    ) as browserFile:
+        browserFile.write(b"")
+
+
+def pathStartsWith(path, *args):
+    prefix = os.path.join(*args)
+    return os.path.commonprefix([path, prefix]) == prefix
+
+
+def convertTestFile(test262parser, testSource, testName, includeSet, strictTests):
+    """
+    Convert a test262 test to a compatible jstests test file.
+    """
+
+    # The test record dictionary, its contents are explained in depth at
+    # <https://github.com/tc39/test262/blob/main/INTERPRETING.md>.
+    testRec = tryParseTestFile(test262parser, testSource.decode("utf-8"), testName)
+
+    # jsreftest meta data
+    refTestOptions = []
+    refTestSkip = []
+    refTestSkipIf = []
+
+    # Skip all files which contain YAML errors.
+    if testRec is None:
+        refTestSkip.append("has YAML errors")
+        testRec = dict()
+
+    # onlyStrict is set when the test must only be run in strict mode.
+    onlyStrict = "onlyStrict" in testRec
+
+    # noStrict is set when the test must not be run in strict mode.
+    noStrict = "noStrict" in testRec
+
+    # The "raw" attribute is used in the default test262 runner to prevent
+    # prepending additional content (use-strict directive, harness files)
+    # before the actual test source code.
+    raw = "raw" in testRec
+
+    # Negative tests have additional meta-data to specify the error type and
+    # when the error is issued (runtime error or early parse error). We're
+    # currently ignoring the error phase attribute.
+    # testRec["negative"] == {type=<error name>, phase=parse|resolution|runtime}
+    isNegative = "negative" in testRec
+    assert not isNegative or type(testRec["negative"]) == dict
+    errorType = testRec["negative"]["type"] if isNegative else None
+
+    # Async tests are marked with the "async" attribute.
+    isAsync = "async" in testRec
+
+    # Test262 tests cannot be both "negative" and "async".  (In principle a
+    # negative async test is permitted when the error phase is not "parse" or
+    # the error type is not SyntaxError, but no such tests exist now.)
+    assert not (isNegative and isAsync), (
+        "Can't have both async and negative attributes: %s" % testName
+    )
+
+    # Only async tests may use the $DONE function.  However, negative parse
+    # tests may "use" the $DONE function (of course they don't actually use it!)
+    # without specifying the "async" attribute.  Otherwise, $DONE must not
+    # appear in the test.
+    assert b"$DONE" not in testSource or isAsync or isNegative, (
+        "Missing async attribute in: %s" % testName
+    )
+
+    # When the "module" attribute is set, the source code is module code.
+    isModule = "module" in testRec
+
+    # CanBlockIsFalse is set when the test expects that the implementation
+    # cannot block on the main thread.
+    if "CanBlockIsFalse" in testRec:
+        refTestSkipIf.append(("xulRuntime.shell", "shell can block main thread"))
+
+    # CanBlockIsTrue is set when the test expects that the implementation
+    # can block on the main thread.
+    if "CanBlockIsTrue" in testRec:
+        refTestSkipIf.append(("!xulRuntime.shell", "browser cannot block main thread"))
+
+    # Skip tests with unsupported features.
+    if "features" in testRec:
+        unsupported = [f for f in testRec["features"] if f in UNSUPPORTED_FEATURES]
+        if unsupported:
+            refTestSkip.append("%s is not supported" % ",".join(unsupported))
+        else:
+            releaseOrBeta = [f for f in testRec["features"] if f in RELEASE_OR_BETA]
+            if releaseOrBeta:
+                refTestSkipIf.append(
+                    (
+                        "release_or_beta",
+                        "%s is not released yet" % ",".join(releaseOrBeta),
+                    )
+                )
+
+            featureCheckNeeded = [
+                f for f in testRec["features"] if f in FEATURE_CHECK_NEEDED
+            ]
+            if featureCheckNeeded:
+                refTestSkipIf.append(
+                    (
+                        "||".join(
+                            [FEATURE_CHECK_NEEDED[f] for f in featureCheckNeeded]
+                        ),
+                        "%s is not enabled unconditionally"
+                        % ",".join(featureCheckNeeded),
+                    )
+                )
+
+            if (
+                "Atomics" in testRec["features"]
+                and "SharedArrayBuffer" in testRec["features"]
+            ):
+                refTestSkipIf.append(
+                    (
+                        "(this.hasOwnProperty('getBuildConfiguration')"
+                        "&&getBuildConfiguration()['arm64-simulator'])",
+                        "ARM64 Simulator cannot emulate atomics",
+                    )
+                )
+
+            shellOptions = {
+                SHELL_OPTIONS[f] for f in testRec["features"] if f in SHELL_OPTIONS
+            }
+            if shellOptions:
+                refTestSkipIf.append(("!xulRuntime.shell", "requires shell-options"))
+                refTestOptions.extend(
+                    ("shell-option({})".format(opt) for opt in sorted(shellOptions))
+                )
+
+    # Includes for every test file in a directory is collected in a single
+    # shell.js file per directory level. This is done to avoid adding all
+    # test harness files to the top level shell.js file.
+    if "includes" in testRec:
+        assert not raw, "Raw test with includes: %s" % testName
+        includeSet.update(testRec["includes"])
+
+    # Add reportCompare() after all positive, synchronous tests.
+    if not isNegative and not isAsync:
+        testEpilogue = "reportCompare(0, 0);"
+    else:
+        testEpilogue = ""
+
+    (terms, comments) = createRefTestEntry(
+        refTestOptions, refTestSkip, refTestSkipIf, errorType, isModule, isAsync
+    )
+    if raw:
+        refTest = ""
+        externRefTest = (terms, comments)
+    else:
+        refTest = createRefTestLine(terms, comments)
+        externRefTest = None
+
+    # Don't write a strict-mode variant for raw or module files.
+    noStrictVariant = raw or isModule
+    assert not (noStrictVariant and (onlyStrict or noStrict)), (
+        "Unexpected onlyStrict or noStrict attribute: %s" % testName
+    )
+
+    # Write non-strict mode test.
+    if noStrictVariant or noStrict or not onlyStrict:
+        testPrologue = ""
+        nonStrictSource = createSource(testSource, refTest, testPrologue, testEpilogue)
+        testFileName = testName
+        yield (testFileName, nonStrictSource, externRefTest)
+
+    # Write strict mode test.
+    if not noStrictVariant and (onlyStrict or (not noStrict and strictTests)):
+        testPrologue = "'use strict';"
+        strictSource = createSource(testSource, refTest, testPrologue, testEpilogue)
+        testFileName = testName
+        if not noStrict:
+            testFileName = addSuffixToFileName(testFileName, "-strict")
+        yield (testFileName, strictSource, externRefTest)
+
+
+def convertFixtureFile(fixtureSource, fixtureName):
+    """
+    Convert a test262 fixture file to a compatible jstests test file.
+    """
+
+    # jsreftest meta data
+    refTestOptions = []
+    refTestSkip = ["not a test file"]
+    refTestSkipIf = []
+    errorType = None
+    isModule = False
+    isAsync = False
+
+    (terms, comments) = createRefTestEntry(
+        refTestOptions, refTestSkip, refTestSkipIf, errorType, isModule, isAsync
+    )
+    refTest = createRefTestLine(terms, comments)
+
+    source = createSource(fixtureSource, refTest, "", "")
+    externRefTest = None
+    yield (fixtureName, source, externRefTest)
+
+
+def process_test262(test262Dir, test262OutDir, strictTests, externManifests):
+    """
+    Process all test262 files and converts them into jstests compatible tests.
+    """
+
+    harnessDir = os.path.join(test262Dir, "harness")
+    testDir = os.path.join(test262Dir, "test")
+    test262parser = loadTest262Parser(test262Dir)
+
+    # Map of test262 subdirectories to the set of include files required for
+    # tests in that subdirectory. The includes for all tests in a subdirectory
+    # are merged into a single shell.js.
+    # map<dirname, set<includeFiles>>
+    includesMap = {}
+
+    # Additional local includes keyed by test262 directory names. The include
+    # files in this map must be located in the js/src/tests directory.
+    # map<dirname, list<includeFiles>>
+    localIncludesMap = {}
+
+    # The root directory contains required harness files and test262-host.js.
+    includesMap[""] = set(["sta.js", "assert.js"])
+    localIncludesMap[""] = ["test262-host.js"]
+
+    # Also add files known to be used by many tests to the root shell.js file.
+    includesMap[""].update(["propertyHelper.js", "compareArray.js"])
+
+    # Write the root shell.js file.
+    writeShellAndBrowserFiles(
+        test262OutDir, harnessDir, includesMap, localIncludesMap, ""
+    )
+
+    # Additional explicit includes inserted at well-chosen locations to reduce
+    # code duplication in shell.js files.
+    explicitIncludes = {}
+    explicitIncludes[os.path.join("built-ins", "Atomics")] = [
+        "testAtomics.js",
+        "testTypedArray.js",
+    ]
+    explicitIncludes[os.path.join("built-ins", "DataView")] = [
+        "byteConversionValues.js"
+    ]
+    explicitIncludes[os.path.join("built-ins", "Promise")] = ["promiseHelper.js"]
+    explicitIncludes[os.path.join("built-ins", "TypedArray")] = [
+        "byteConversionValues.js",
+        "detachArrayBuffer.js",
+        "nans.js",
+    ]
+    explicitIncludes[os.path.join("built-ins", "TypedArrays")] = [
+        "detachArrayBuffer.js"
+    ]
+
+    # Process all test directories recursively.
+    for (dirPath, dirNames, fileNames) in os.walk(testDir):
+        relPath = os.path.relpath(dirPath, testDir)
+        if relPath == ".":
+            continue
+
+        # Skip creating a "prs" directory if it already exists
+        if relPath not in ("prs", "local") and not os.path.exists(
+            os.path.join(test262OutDir, relPath)
+        ):
+            os.makedirs(os.path.join(test262OutDir, relPath))
+
+        includeSet = set()
+        includesMap[relPath] = includeSet
+
+        if relPath in explicitIncludes:
+            includeSet.update(explicitIncludes[relPath])
+
+        # Convert each test file.
+        for fileName in fileNames:
+            filePath = os.path.join(dirPath, fileName)
+            testName = os.path.relpath(filePath, testDir)
+
+            # Copy non-test files as is.
+            (_, fileExt) = os.path.splitext(fileName)
+            if fileExt != ".js":
+                shutil.copyfile(filePath, os.path.join(test262OutDir, testName))
+                continue
+
+            # Files ending with "_FIXTURE.js" are fixture files:
+            # https://github.com/tc39/test262/blob/main/INTERPRETING.md#modules
+            isFixtureFile = fileName.endswith("_FIXTURE.js")
+
+            # Read the original test source and preprocess it for the jstests harness.
+            with io.open(filePath, "rb") as testFile:
+                testSource = testFile.read()
+
+            if isFixtureFile:
+                convert = convertFixtureFile(testSource, testName)
+            else:
+                convert = convertTestFile(
+                    test262parser, testSource, testName, includeSet, strictTests
+                )
+
+            for (newFileName, newSource, externRefTest) in convert:
+                writeTestFile(test262OutDir, newFileName, newSource)
+
+                if externRefTest is not None:
+                    externManifests.append(
+                        {
+                            "name": newFileName,
+                            "reftest": externRefTest,
+                        }
+                    )
+
+        # Add shell.js and browers.js files for the current directory.
+        writeShellAndBrowserFiles(
+            test262OutDir, harnessDir, includesMap, localIncludesMap, relPath
+        )
+
+
+def fetch_local_changes(inDir, outDir, srcDir, strictTests):
+    """
+    Fetch the changes from a local clone of Test262.
+
+    1. Get the list of file changes made by the current branch used on Test262 (srcDir).
+    2. Copy only the (A)dded, (C)opied, (M)odified, and (R)enamed files to inDir.
+    3. inDir is treated like a Test262 checkout, where files will be converted.
+    4. Fetches the current branch name to set the outDir.
+    5. Processed files will be added to `<outDir>/local/<branchName>`.
+    """
+    import subprocess
+
+    # TODO: fail if it's in the default branch? or require a branch name?
+
+    # Checks for unstaged or non committed files. A clean branch provides a clean status.
+    status = subprocess.check_output(
+        ("git -C %s status --porcelain" % srcDir).split(" ")
+    )
+
+    if status.strip():
+        raise RuntimeError(
+            "Please commit files and cleanup the local test262 folder before importing files.\n"
+            "Current status: \n%s" % status
+        )
+
+    # Captures the branch name to be used on the output
+    branchName = subprocess.check_output(
+        ("git -C %s rev-parse --abbrev-ref HEAD" % srcDir).split(" ")
+    ).split("\n")[0]
+
+    # Fetches the file names to import
+    files = subprocess.check_output(
+        ("git -C %s diff main --diff-filter=ACMR --name-only" % srcDir).split(" ")
+    )
+
+    # Fetches the deleted files to print an output log. This can be used to
+    # set up the skip list, if necessary.
+    deletedFiles = subprocess.check_output(
+        ("git -C %s diff main --diff-filter=D --name-only" % srcDir).split(" ")
+    )
+
+    # Fetches the modified files as well for logging to support maintenance
+    # in the skip list.
+    modifiedFiles = subprocess.check_output(
+        ("git -C %s diff main --diff-filter=M --name-only" % srcDir).split(" ")
+    )
+
+    # Fetches the renamed files for the same reason, this avoids duplicate
+    # tests if running the new local folder and the general imported Test262
+    # files.
+    renamedFiles = subprocess.check_output(
+        ("git -C %s diff main --diff-filter=R --summary" % srcDir).split(" ")
+    )
+
+    # Print some friendly output
+    print("From the branch %s in %s \n" % (branchName, srcDir))
+    print("Files being copied to the local folder: \n%s" % files)
+    if deletedFiles:
+        print(
+            "Deleted files (use this list to update the skip list): \n%s" % deletedFiles
+        )
+    if modifiedFiles:
+        print(
+            "Modified files (use this list to update the skip list): \n%s"
+            % modifiedFiles
+        )
+    if renamedFiles:
+        print("Renamed files (already added with the new names): \n%s" % renamedFiles)
+
+    for f in files.splitlines():
+        # Capture the subdirectories names to recreate the file tree
+        # TODO: join the file tree with -- instead of multiple subfolders?
+        fileTree = os.path.join(inDir, os.path.dirname(f))
+        if not os.path.exists(fileTree):
+            os.makedirs(fileTree)
+
+        shutil.copyfile(
+            os.path.join(srcDir, f), os.path.join(fileTree, os.path.basename(f))
+        )
+
+    # Extras from Test262. Copy the current support folders - including the
+    # harness - for a proper conversion process
+    shutil.copytree(os.path.join(srcDir, "tools"), os.path.join(inDir, "tools"))
+    shutil.copytree(os.path.join(srcDir, "harness"), os.path.join(inDir, "harness"))
+
+    # Reset any older directory in the output using the same branch name
+    outDir = os.path.join(outDir, "local", branchName)
+    if os.path.isdir(outDir):
+        shutil.rmtree(outDir)
+    os.makedirs(outDir)
+
+    process_test262(inDir, outDir, strictTests, [])
+
+
+def fetch_pr_files(inDir, outDir, prNumber, strictTests):
+    import requests
+
+    prTestsOutDir = os.path.join(outDir, "prs", prNumber)
+    if os.path.isdir(prTestsOutDir):
+        print("Removing folder %s" % prTestsOutDir)
+        shutil.rmtree(prTestsOutDir)
+    os.makedirs(prTestsOutDir)
+
+    # Reuses current Test262 clone's harness and tools folders only, the clone's test/
+    # folder can be discarded from here
+    shutil.rmtree(os.path.join(inDir, "test"))
+
+    prRequest = requests.get(
+        "https://api.github.com/repos/tc39/test262/pulls/%s" % prNumber
+    )
+    prRequest.raise_for_status()
+
+    pr = prRequest.json()
+
+    if pr["state"] != "open":
+        # Closed PR, remove respective files from folder
+        return print("PR %s is closed" % prNumber)
+
+    files = requests.get(
+        "https://api.github.com/repos/tc39/test262/pulls/%s/files" % prNumber
+    )
+    files.raise_for_status()
+
+    for item in files.json():
+        if not item["filename"].startswith("test/"):
+            continue
+
+        filename = item["filename"]
+        fileStatus = item["status"]
+
+        print("%s %s" % (fileStatus, filename))
+
+        # Do not add deleted files
+        if fileStatus == "removed":
+            continue
+
+        contents = requests.get(item["raw_url"])
+        contents.raise_for_status()
+
+        fileText = contents.text
+
+        filePathDirs = os.path.join(inDir, *filename.split("/")[:-1])
+
+        if not os.path.isdir(filePathDirs):
+            os.makedirs(filePathDirs)
+
+        with io.open(os.path.join(inDir, *filename.split("/")), "wb") as output_file:
+            output_file.write(fileText.encode("utf8"))
+
+    process_test262(inDir, prTestsOutDir, strictTests, [])
+
+
+def general_update(inDir, outDir, strictTests):
+    import subprocess
+
+    restoreLocalTestsDir = False
+    restorePrsTestsDir = False
+    localTestsOutDir = os.path.join(outDir, "local")
+    prsTestsOutDir = os.path.join(outDir, "prs")
+
+    # Stash test262/local and test262/prs. Currently the Test262 repo does not have any
+    # top-level subdirectories named "local" or "prs".
+    # This prevents these folders from being removed during the update process.
+    if os.path.isdir(localTestsOutDir):
+        shutil.move(localTestsOutDir, inDir)
+        restoreLocalTestsDir = True
+
+    if os.path.isdir(prsTestsOutDir):
+        shutil.move(prsTestsOutDir, inDir)
+        restorePrsTestsDir = True
+
+    # Create the output directory from scratch.
+    if os.path.isdir(outDir):
+        shutil.rmtree(outDir)
+    os.makedirs(outDir)
+
+    # Copy license file.
+    shutil.copyfile(os.path.join(inDir, "LICENSE"), os.path.join(outDir, "LICENSE"))
+
+    # Create the git info file.
+    with io.open(os.path.join(outDir, "GIT-INFO"), "w", encoding="utf-8") as info:
+        subprocess.check_call(["git", "-C", inDir, "log", "-1"], stdout=info)
+
+    # Copy the test files.
+    externManifests = []
+    process_test262(inDir, outDir, strictTests, externManifests)
+
+    # Create the external reftest manifest file.
+    with io.open(os.path.join(outDir, "jstests.list"), "wb") as manifestFile:
+        manifestFile.write(b"# GENERATED, DO NOT EDIT\n\n")
+        for externManifest in sorted(externManifests, key=itemgetter("name")):
+            (terms, comments) = externManifest["reftest"]
+            if terms:
+                entry = "%s script %s%s\n" % (
+                    terms,
+                    externManifest["name"],
+                    (" # %s" % comments) if comments else "",
+                )
+                manifestFile.write(entry.encode("utf-8"))
+
+    # Move test262/local back.
+    if restoreLocalTestsDir:
+        shutil.move(os.path.join(inDir, "local"), outDir)
+
+    # Restore test262/prs if necessary after a general Test262 update.
+    if restorePrsTestsDir:
+        shutil.move(os.path.join(inDir, "prs"), outDir)
+
+
+def update_test262(args):
+    import subprocess
+
+    url = args.url
+    branch = args.branch
+    revision = args.revision
+    outDir = args.out
+    prNumber = args.pull
+    srcDir = args.local
+
+    if not os.path.isabs(outDir):
+        outDir = os.path.join(os.getcwd(), outDir)
+
+    strictTests = args.strict
+
+    # Download the requested branch in a temporary directory.
+    with TemporaryDirectory() as inDir:
+        # If it's a local import, skip the git clone parts.
+        if srcDir:
+            return fetch_local_changes(inDir, outDir, srcDir, strictTests)
+
+        if revision == "HEAD":
+            subprocess.check_call(
+                ["git", "clone", "--depth=1", "--branch=%s" % branch, url, inDir]
+            )
+        else:
+            subprocess.check_call(
+                ["git", "clone", "--single-branch", "--branch=%s" % branch, url, inDir]
+            )
+            subprocess.check_call(["git", "-C", inDir, "reset", "--hard", revision])
+
+        # If a PR number is provided, fetches only the new and modified files
+        # from that PR. It also creates a new folder for that PR or replaces if
+        # it already exists, without updating the regular Test262 tests.
+        if prNumber:
+            return fetch_pr_files(inDir, outDir, prNumber, strictTests)
+
+        # Without a PR or a local import, follows through a regular copy.
+        general_update(inDir, outDir, strictTests)
+
+
+if __name__ == "__main__":
+    import argparse
+
+    # This script must be run from js/src/tests to work correctly.
+    if "/".join(os.path.normpath(os.getcwd()).split(os.sep)[-3:]) != "js/src/tests":
+        raise RuntimeError("%s must be run from js/src/tests" % sys.argv[0])
+
+    parser = argparse.ArgumentParser(description="Update the test262 test suite.")
+    parser.add_argument(
+        "--url",
+        default="git://github.com/tc39/test262.git",
+        help="URL to git repository (default: %(default)s)",
+    )
+    parser.add_argument(
+        "--branch", default="main", help="Git branch (default: %(default)s)"
+    )
+    parser.add_argument(
+        "--revision", default="HEAD", help="Git revision (default: %(default)s)"
+    )
+    parser.add_argument(
+        "--out",
+        default="test262",
+        help="Output directory. Any existing directory will be removed!"
+        "(default: %(default)s)",
+    )
+    parser.add_argument(
+        "--pull", help="Import contents from a Pull Request specified by its number"
+    )
+    parser.add_argument(
+        "--local",
+        help="Import new and modified contents from a local folder, a new folder "
+        "will be created on local/branch_name",
+    )
+    parser.add_argument(
+        "--strict",
+        default=False,
+        action="store_true",
+        help="Generate additional strict mode tests. Not enabled by default.",
+    )
+    parser.set_defaults(func=update_test262)
+    args = parser.parse_args()
+    args.func(args)