Fix bug in _SimpleUri.resolve.

sdk/lib/core/uri.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of dart.core;
 
 // Frequently used character codes.
 const int _SPACE = 0x20;
 const int _PERCENT = 0x25;
 const int _PLUS = 0x2B;
@@ skipping 4305 matching lines @@
       return new _SimpleUri(newUri,
         base._schemeEnd,
         base._hostStart,
         base._portStart,
         base._pathStart,
         ref._queryStart + delta,
         ref._fragmentStart + delta,
         base._schemeCache);
     }
     // Merge paths.
-    if (base._uri.startsWith("../", base._pathStart)) {
-      // Complex rare case, go slow.
-      return _toNonSimple().resolveUri(ref);
-    }
 
     // The RFC 3986 algorithm merges the base path without its final segment
     // (anything after the final "/", or everything if the base path doesn't
     // contain any "/"), and the reference path.
     // Then it removes "." and ".." segments using the remove-dot-segment
     // algorithm.
     // This code combines the two steps. It is simplified by knowing that
     // the base path contains no "." or ".." segments, and the reference
     // path can only contain leading ".." segments.
 
     String baseUri = base._uri;
     String refUri = ref._uri;
     int baseStart = base._pathStart;
     int baseEnd = base._queryStart;
+    while (baseUri.startsWith("../", baseStart)) baseStart += 3;
     int refStart = ref._pathStart;
     int refEnd = ref._queryStart;
-    int backCount = 1;
+    int backCount = 0;

[eernst, 2016/09/29 12:28:49]

It would help to document this variable. Is it something like this?:
// Number of "../" in `refUri.substring(0, refStart)` that
// we haven't eliminated by matching up with the end of `baseUri`.

[Lasse Reichstein Nielsen, 2016/09/29 12:58:30]

Done.

 
     int slashCount = 0;
 
     // Count leading ".." segments in reference path.
     while (refStart + 3 <= refEnd && refUri.startsWith("../", refStart)) {
       refStart += 3;
       backCount += 1;
     }
 
     // Extra slash inserted between base and reference path parts if
     // the base path contains any slashes.
     // (We could use a slash from the base path in most cases, but not if
     // we remove the entire base path).
     String insert = "";
     while (baseEnd > baseStart) {
       baseEnd--;
       int char = baseUri.codeUnitAt(baseEnd);
       if (char == _SLASH) {
         insert = "/";
+        if (backCount == 0) break;
         backCount--;
-        if (backCount == 0) break;
       }
     }

[eernst, 2016/09/29 12:28:49]

This while loop seems to cut off segments starting with slashes (like
"/some-path-element"). It would be nice to have a comment hinting on the main
purpose of the loop, not just the corner case. (It might seem obvious to you
right now, but it gets a bit less obvious when trying to do a fixed point
operation of the partially known meaning of several variables).

[Lasse Reichstein Nielsen, 2016/09/29 12:58:30]

Done.

-    // If the base URI has no scheme or authority (`_pathStart == 0`)
-    // and a relative path, and we reached the beginning of the path,
-    // we have a special case.
-    if (baseEnd == 0 && !base.hasAbsolutePath) {
-      // Non-RFC 3986 behavior when resolving a purely relative path on top of
-      // another relative path: Don't make the result absolute.
-      insert = "";
+
+    if (!base.hasScheme && !base.hasAbsolutePath) {
+      // If the base is *just* a relative path (no scheme or authority),
+      // then merging with another relative path doesn't follow the
+      // RFC-3986 behavior.
+      // Don't need to check `base.hasAuthority` since the base path is
+      // non-empty - if there is an authority, a non-empty path is absolute.
+      if (backCount > 0) {
+        // We reached the start of the base path with more "../" left over
+        // in the reference path. Include those in the result.
+        refStart -= backCount * 3;
+        insert = "";
+      } else if (baseEnd == baseStart) {
+        // We reached the start of the base path with no more "../" left
+        // over, so don't insert a "/" - that would make the result absolute.

[eernst, 2016/09/29 12:28:49]

Would be nice to have an explicit "this is the case where we differ from RFC
3986" here (ah! - we used to have that, too).

[Lasse Reichstein Nielsen, 2016/09/29 12:58:30]

That is what it says right above (look for RFC-3986).

I've reordered the logic here so it's easier to understand.

+        insert = "";
+      }
     }
 
     var delta = baseEnd - refStart + insert.length;
     var newUri = "${base._uri.substring(0, baseEnd)}$insert"
                "${ref._uri.substring(refStart)}";
 
     return new _SimpleUri(newUri,
       base._schemeEnd,
       base._hostStart,
       base._portStart,
@@ skipping 71 matching lines @@
   int delta = (text.codeUnitAt(start + 4) ^ _COLON) * 3;
   delta |= text.codeUnitAt(start)     ^ 0x64 /*d*/;
   delta |= text.codeUnitAt(start + 1) ^ 0x61 /*a*/;
   delta |= text.codeUnitAt(start + 2) ^ 0x74 /*t*/;
   delta |= text.codeUnitAt(start + 3) ^ 0x61 /*a*/;
   return delta;
 }
 
 /// Helper function returning the length of a string, or `0` for `null`.
 int _stringOrNullLength(String s) => (s == null) ? 0 : s.length;