[Dexter] Use PurePath to compare paths in Dexter commands

[StephenTozer]

Summary

Prior to this patch, when comparing the paths of source files in Dexter commands, we would use os.samefile. This function performs actual file operations and requires the files to exist on the current system; this is suitable when running the test for the first time, but renders the DextIR output files non-portable, and unusable if the source files no longer exist in their original location.

[Orlando]

LGTM

[jmorse]

I endorse anything that involves touching the filesystem less in the middle of tools. Hurrah!

cross-project-tests/debuginfo-tests/dexter/dex/command/commands/DexDeclareAddress.py

 # DExTer : Debugging Experience Tester
 # ~~~~~~   ~         ~~         ~   ~~
 #
 # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 # See https://llvm.org/LICENSE.txt for license information.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 """Commmand sets the path for all following commands to 'declared_file'.
 """
 
 import os
+from pathlib import PurePath
 
 from dex.command.CommandBase import CommandBase, StepExpectInfo
 
 class DexDeclareAddress(CommandBase):
     def __init__(self, addr_name, expression, **kwargs):
 
         if not isinstance(addr_name, str):
             raise TypeError('invalid argument type')
class DexDeclareAddress(CommandBase):
 
     def get_watches(self):
         return [StepExpectInfo(self.expression, self.path, 0, range(self.on_line, self.on_line + 1))]
 
     def get_address_name(self):
         return self.addr_name
 
     def eval(self, step_collection):
-        assert os.path.exists(self.path)
         self.address_resolutions[self.get_address_name()] = None
         for step in step_collection.steps:
             loc = step.current_location
 
-            if (loc.path and os.path.exists(loc.path) and
-                os.path.samefile(loc.path, self.path) and
+            if (loc.path and self.path and
+                PurePath(loc.path) == PurePath(self.path) and
                 loc.lineno == self.on_line):
                 if self.hit_count > 0:
                     self.hit_count -= 1
                     continue
                 try:
                     watch = step.program_state.frames[0].watches[self.expression]
                 except KeyError:
                     continue
                 try:
                     hex_val = int(watch.value, 16)
                 except ValueError:
                     hex_val = None
                 self.address_resolutions[self.get_address_name()] = hex_val
                 break

cross-project-tests/debuginfo-tests/dexter/dex/command/commands/DexExpectWatchBase.py

 # DExTer : Debugging Experience Tester
 # ~~~~~~   ~         ~~         ~   ~~
 #
 # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 # See https://llvm.org/LICENSE.txt for license information.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
 """DexExpectWatch base class, holds logic for how to build and process expected
  watch commands.
 """
 
 import abc
 import difflib
 import os
 import math
 from collections import namedtuple
+from pathlib import PurePath
 
 from dex.command.CommandBase import CommandBase, StepExpectInfo
 from dex.command.StepValueInfo import StepValueInfo
 
 class AddressExpression(object):
     def __init__(self, name, offset=0):
         self.name = name
         self.offset = offset
def _check_watch_order(self, actual_watches, expected_values):
                 differences.append(actual_watches[index])
                 index += 1
             else:
                 assert False, 'unexpected diff:{}'.format(vd)
 
         return differences
 
     def eval(self, step_collection):
-        assert os.path.exists(self.path)
         for step in step_collection.steps:
             loc = step.current_location
 
-            if (loc.path and os.path.exists(loc.path) and
-                os.path.samefile(loc.path, self.path) and
+            if (loc.path and self.path and
+                PurePath(loc.path) == PurePath(self.path) and
                 loc.lineno in self.line_range):
                 try:
                     watch = step.program_state.frames[0].watches[self.expression]
                 except KeyError:
                     pass
                 else:
                     expected_field = self._get_expected_field(watch)
                     step_info = StepValueInfo(step.step_index, watch, 

cross-project-tests/debuginfo-tests/dexter/dex/dextIR/ProgramState.py

 # DExTer : Debugging Experience Tester
 # ~~~~~~   ~         ~~         ~   ~~
 #
 # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 # See https://llvm.org/LICENSE.txt for license information.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 """Set of data classes for representing the complete debug program state at a
 fixed point in execution.
 """
 
 import os
 
 from collections import OrderedDict
+from pathlib import PurePath
 from typing import List
 
 class SourceLocation:
     def __init__(self, path: str = None, lineno: int = None, column: int = None):
         if path:
             path = os.path.normcase(path)
         self.path = path
         self.lineno = lineno
         self.column = column
 
     def __str__(self):
         return '{}({}:{})'.format(self.path, self.lineno, self.column)
 
     def match(self, other) -> bool:
         """Returns true iff all the properties that appear in `self` have the
         same value in `other`, but not necessarily vice versa.
         """
         if not other or not isinstance(other, SourceLocation):
             return False
 
-        if self.path and (self.path != other.path):
+        if self.path and (other.path is None or (PurePath(self.path) != PurePath(other.path))):
             return False
 
         if self.lineno and (self.lineno != other.lineno):
             return False
 
         if self.column and (self.column != other.column):
             return False