win, fs: fix realpath behavior on substed drives

lib/fs.js

@@ -1562,6 +1562,8 @@ fs.unwatchFile = function(filename, listener) {
   }
 };
 
+// Cache for JS real path 
+var realpathCache = {};
 // Regexp that finds the next partion of a (partial) path
 // result is [base_with_slash, base], e.g. ['somedir/', 'somedir']
 const nextPartRe = isWindows ?
@@ -1669,6 +1671,25 @@ function realpathSyncJS(p, cache) {
   return p;
 };
 
+function realpathJSNeeded(resolvedPath, result, err) {
+  if (!isWindows || err)
+    return false;
+  const resultStr = result.toString('utf8');
+  return resultStr.length > 0 && resolvedPath.length > 0 &&
+         resultStr[0].toUpperCase() !== resolvedPath[0].toUpperCase();
+};
+
+function convertRealpathJSResult(result, encoding, err) {
+  if (!encoding || encoding === 'utf8' || err)
+    return result;
+  const asBuffer = Buffer.from(result);
+  if (encoding === 'buffer') {
+    return asBuffer;
+  } else {
+    return asBuffer.toString(encoding);
+  }
+};
+
 fs.realpathSync = function realpathSync(path, options) {
   if (!options)
     options = {};
@@ -1677,7 +1698,16 @@ fs.realpathSync = function realpathSync(path, options) {
   else if (typeof options !== 'object')
     throw new TypeError('"options" must be a string or an object');
   nullCheck(path);
-  return binding.realpath(pathModule._makeLong(path), options.encoding);
+  const resolvedPath = pathModule.resolve(path.toString('utf8'));
+  const uvResult = binding.realpath(pathModule._makeLong(resolvedPath),
+                                    options.encoding);
+  if (realpathJSNeeded(resolvedPath, uvResult))
+  {
+    const jsResult = realpathSyncJS(resolvedPath, realpathCache);
+    return convertRealpathJSResult(jsResult, options.encoding);
+  } else {
+    return uvResult;
+  }
 };
 
 function realpathJS(p, cache, cb) {
@@ -1813,11 +1843,25 @@ fs.realpath = function realpath(path, options, callback) {
   } else if (typeof options !== 'object') {
     throw new TypeError('"options" must be a string or an object');
   }
-  callback = makeCallback(callback);
   if (!nullCheck(path, callback))
     return;
+
+  const resolvedPath = pathModule.resolve(path.toString('utf8'));
+  const win32callback = function(err, result) {
+    if (realpathJSNeeded(resolvedPath, result, err)) {
+      realpathJS(resolvedPath, realpathCache, function(err, result) {
+        result = convertRealpathJSResult(result, options.encoding, err);
+        return callback(err, result);
+      });
+    } else {
+      return callback(err, result);
+    }
+  };
+
+  const use_callback = makeCallback(isWindows ? win32callback : callback);
+
   var req = new FSReqWrap();
-  req.oncomplete = callback;
+  req.oncomplete = use_callback;
   binding.realpath(pathModule._makeLong(path), options.encoding, req);
   return;
 };

test/parallel/test-fs-realpath-subst-drive.js

@@ -0,0 +1,58 @@
+const common = require('../common');
+const assert = require('assert');
+const fs = require('fs');
+const spawnSync = require('child_process').spawnSync;
+
+if (!common.isWindows) {
+  common.skip("Test for Windows only");
+  return;
+}
+let result;
+
+// create a subst drive
+const driveLetters = "ABCDEFGHIJKLMNOPQRSTUWXYZ";
+let driveLetter;
+for (var i = 0; i < driveLetters.length; ++i) {
+  driveLetter = `${driveLetters[i]}:`
+   result = spawnSync('subst', [driveLetter, common.fixturesDir]);
+  if (result.status === 0)
+    break;
+}
+if (i === driveLetters.length) {
+  common.skip("Cannot create subst drive");
+  return;
+}
+
+var asyncCompleted = 0;
+// schedule cleanup (and check if all callbacks where called)
+process.on('exit', function() {
+    spawnSync('subst', ['/d', driveLetter]);
+    assert.equal(asyncCompleted, 2);
+});
+
+
+// test:
+const filename = `${driveLetter}\\empty.js`;
+const filenameBuffer = Buffer.from(filename);
+
+result = fs.realpathSync(filename);
+assert.equal(typeof result, 'string');
+assert.equal(result, filename);
+
+result = fs.realpathSync(filename, 'buffer');
+assert(Buffer.isBuffer(result));
+assert(result.equals(filenameBuffer));
+
+fs.realpath(filename, function(err, result) {
+  ++asyncCompleted;
+  assert(!err);
+  assert.equal(typeof result, 'string');
+  assert.equal(result, filename);
+});
+
+fs.realpath(filename, 'buffer', function(err, result) {
+  ++asyncCompleted;
+  assert(!err);
+  assert(Buffer.isBuffer(result));
+  assert(result.equals(filenameBuffer));
+});