lit: Don't make with_environment() change case of existing PATH entries.

[thakis]

Summary

This is an alternative fix for https://reviews.llvm.org/D57343.
Instead of normcase()ing in which() in addition to in
with_environment(), consistently don't do it in both places.

Since normcase() is lossy (the original, likely "true" on-disk case
is lost), only computing a normcase() in-memory while comparing
seems overall less surprising.

No intended behavior change, except that binaries returned by which()
will now have on-disk case again, like before D57343.

llvm/utils/lit/lit/llvm/config.py

def with_environment(self, variable, value, append_path=False):
             # all of them.
             paths_to_add = value
             if lit.util.is_string(paths_to_add):
                 paths_to_add = [paths_to_add]
 
             def norm(x):
                 return os.path.normcase(os.path.normpath(x))
 
-            current_paths = self.config.environment.get(variable, None)
-            if current_paths:
-                current_paths = current_paths.split(os.path.pathsep)
-                paths = [norm(p) for p in current_paths]
+            paths = self.config.environment.get(variable, None)
+            if paths:
+                paths = paths.split(os.path.pathsep)
             else:
                 paths = []
 
             # If we are passed a list [a b c], then iterating this list forwards
             # and adding each to the beginning would result in b c a.  So we
             # need to iterate in reverse to end up with the original ordering.
             for p in reversed(paths_to_add):
                 # Move it to the front if it already exists, otherwise insert
                 # it at the beginning.
-                p = norm(p)
                 try:
-                    paths.remove(p)
+                    paths.pop(map(norm, paths).index(norm(p)))
                 except ValueError:
                     pass
                 paths = [p] + paths
             value = os.pathsep.join(paths)
         self.config.environment[variable] = value
 
     def with_system_environment(self, variables, append_path=False):
         if lit.util.is_string(variables):

llvm/utils/lit/lit/util.py

def which(command, paths=None):
     """which(command, [paths]) - Look up the given command in the paths string
     (or the PATH environment variable, if unspecified)."""
 
     if paths is None:
         paths = os.environ.get('PATH', '')
 
     # Check for absolute match first.
     if os.path.isabs(command) and os.path.isfile(command):
-        return os.path.normcase(os.path.normpath(command))
+        return os.path.normpath(command)
 
     # Would be nice if Python had a lib function for this.
     if not paths:
         paths = os.defpath
 
     # Get suffixes to search.
     # On Cygwin, 'PATHEXT' may exist but it should not be used.
     if os.pathsep == ';':
         pathext = os.environ.get('PATHEXT', '').split(';')
     else:
         pathext = ['']
 
     # Search the paths...
     for path in paths.split(os.pathsep):
         for ext in pathext:
             p = os.path.join(path, command + ext)
             if os.path.exists(p) and not os.path.isdir(p):
-                return os.path.normcase(os.path.normpath(p))
+                return os.path.normpath(p)
 
     return None
 
 
 def checkToolsPath(dir, tools):
     for tool in tools:
         if not os.path.exists(os.path.join(dir, tool)):
             return False