DevTools: linkifier incorrectly matches port numbers in urls as line numbers

third_party/WebKit/Source/devtools/front_end/common/ParsedURL.js

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  * 1. Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *
@@ skipping 30 matching lines @@
     this.port = '';
     this.path = '';
     this.queryParams = '';
     this.fragment = '';
     this.folderPathComponents = '';
     this.lastPathComponent = '';
 
     var match = url.match(Common.ParsedURL._urlRegex());
     if (match) {
       this.isValid = true;
-      this.scheme = match[1].toLowerCase();
-      this.host = match[2];
-      this.port = match[3];
-      this.path = match[4] || '/';
-      this.queryParams = match[5] || '';
-      this.fragment = match[6];
+      this.scheme = match[2].toLowerCase();
+      this.host = match[3];
+      this.port = match[4];
+      this.path = match[5] || '/';
+      this.queryParams = match[6] || '';
+      this.fragment = match[7];
     } else {
       if (this.url.startsWith('data:')) {
         this.scheme = 'data';
         return;
       }
       if (this.url === 'about:blank') {
         this.scheme = 'about';
         return;
       }
       this.path = this.url;
@@ skipping 23 matching lines @@
     return fileSystemPath;
   }
 
   /**
    * @return {!RegExp}
    */
   static _urlRegex() {
     if (Common.ParsedURL._urlRegexInstance)
       return Common.ParsedURL._urlRegexInstance;
     // RegExp groups:
-    // 1 - scheme (using the RFC3986 grammar)
-    // 2 - hostname
-    // 3 - ?port
-    // 4 - ?path
-    // 5 - ?query
-    // 6 - ?fragment
+    // 1 - scheme, hostname, ?port
+    // 2 - scheme (using the RFC3986 grammar)
+    // 3 - hostname
+    // 4 - ?port
+    // 5 - ?path
+    // 6 - ?query
+    // 7 - ?fragment
     var schemeRegex = /([A-Za-z][A-Za-z0-9+.-]*):\/\//;
     var hostRegex = /([^\s\/:]*)/;
     var portRegex = /(?::([\d]+))?/;
     var pathRegex = /(\/[^#?]*)?/;
     var queryRegex = /(?:\?([^#]*))?/;
     var fragmentRegex = /(?:#(.*))?/;
 
     Common.ParsedURL._urlRegexInstance = new RegExp(
-        '^' + schemeRegex.source + hostRegex.source + portRegex.source + pathRegex.source + queryRegex.source +
+        '^(' + schemeRegex.source + hostRegex.source + portRegex.source + ')' + pathRegex.source + queryRegex.source +
         fragmentRegex.source + '$');
     return Common.ParsedURL._urlRegexInstance;
   }
 
   /**
    * @param {string} url
    * @return {string}
    */
   static extractPath(url) {
     var parsedURL = url.asParsedURL();
@@ skipping 78 matching lines @@
     if (hrefPath.charAt(0) !== '/')
       hrefPath = parsedURL.folderPathComponents + '/' + hrefPath;
     return securityOrigin + Runtime.normalizePath(hrefPath) + hrefSuffix;
   }
 
   /**
    * @param {string} string
    * @return {!{url: string, lineNumber: (number|undefined), columnNumber: (number|undefined)}}
    */
   static splitLineAndColumn(string) {
+    // Only look for line and column numbers in the path to avoid matching port numbers.
+    var beforePathMatch = string.match(Common.ParsedURL._urlRegex());

[alph, 2017/04/26 22:00:05]

Can't you just use lastPathComponentWithFragment() instead?

[luoe, 2017/04/26 23:45:05]

It doesn't include queryParams, but we could add it.  Even with the
lastPathComponentWithFragment, I think the new regex group makes it simpler to
assemble the string before it.  Without adding a new regex group, we'd need to
introduce something like stringBeforeLastPathComponent =
`match[2] + '://' + match[3] + (match[4] ? (':' + match[4]) : match[4]) +
match[5];`

If patching the old regex with a new matching group isn't good, wdyt about
making a new regex just for this case?

+    var beforePath = '';
+    var pathAndAfter = string;
+    if (beforePathMatch) {
+      beforePath = beforePathMatch[1];
+      pathAndAfter = string.substring(beforePathMatch[1].length);
+    }
+
     var lineColumnRegEx = /(?::(\d+))?(?::(\d+))?$/;
-    var lineColumnMatch = lineColumnRegEx.exec(string);
+    var lineColumnMatch = lineColumnRegEx.exec(pathAndAfter);
     var lineNumber;
     var columnNumber;
     console.assert(lineColumnMatch);
 
     if (typeof(lineColumnMatch[1]) === 'string') {
       lineNumber = parseInt(lineColumnMatch[1], 10);
       // Immediately convert line and column to 0-based numbers.
       lineNumber = isNaN(lineNumber) ? undefined : lineNumber - 1;
     }
     if (typeof(lineColumnMatch[2]) === 'string') {
       columnNumber = parseInt(lineColumnMatch[2], 10);
       columnNumber = isNaN(columnNumber) ? undefined : columnNumber - 1;
     }
 
     return {
-      url: string.substring(0, string.length - lineColumnMatch[0].length),
+      url: beforePath + pathAndAfter.substring(0, pathAndAfter.length - lineColumnMatch[0].length),
       lineNumber: lineNumber,
       columnNumber: columnNumber
     };
   }
 
   /**
    * @param {string} url
    * @return {boolean}
    */
   static isRelativeURL(url) {
@@ skipping 81 matching lines @@
 
 /**
  * @return {?Common.ParsedURL}
  */
 String.prototype.asParsedURL = function() {
   var parsedURL = new Common.ParsedURL(this.toString());
   if (parsedURL.isValid)
     return parsedURL;
   return null;
 };