Use a scanning algorithm for closing tags map

Author: fdecampredon

src/compiler/parser.ts

@@ -3104,31 +3104,9 @@ module ts {
             return "";
         }
 
-        function retrieveClosingTagsMap(): Map<number[]> {
-            const closingTagsMap: Map<number[]> = {};
-            // Unfortunately this regex won't catch linebreak inside the tagName 
-            // ie: </MyModule.\nmyProperty>
-            // We could use [\s\S], but it could cause matching gigantic tagname 
-            // of multiple lines of valid typescript code.
-            const jsxClosingTagRegEx = /<\/\s*(.+?)\s*>/g;
-            while (true) {
-                const match = jsxClosingTagRegEx.exec(sourceText)
-                if (match) {
-                    const tag = match[1].replace(/\s/g, "");
-                    if (!hasProperty(closingTagsMap, tag)) {
-                        closingTagsMap[tag] = [];
-                    }
-                    closingTagsMap[tag].push(match.index);
-                } else {
-                    break;
-                }
-            }
-            return closingTagsMap;
-        }
-
         function hasClosingTagAfterPos(tagName: string, currentPos: number): boolean {
             if (!closingTagsMap) {
-                closingTagsMap = retrieveClosingTagsMap();
+                closingTagsMap = retrieveClosingTagsMap(sourceText, sourceFile.languageVersion);
             }
             return hasProperty(closingTagsMap, tagName) && forEach(closingTagsMap[tagName], p => p >= currentPos);
         }

src/compiler/scanner.ts

@@ -601,7 +601,40 @@ module ts {
             ch >= CharacterCodes._0 && ch <= CharacterCodes._9 || ch === CharacterCodes.$ || ch === CharacterCodes._ ||
             ch > CharacterCodes.maxAsciiCharacter && isUnicodeIdentifierPart(ch, languageVersion);
     }
-
+    
+    /* @internal */ 
+    export function retrieveClosingTagsMap(text: string, languageVersion: ScriptTarget): Map<number[]> {
+        let pos = 0;
+        let end = text.length;
+        const closingTags: Map<number[]> = {};
+        while (pos < end) {
+            if (text.charCodeAt(pos) === CharacterCodes.lessThan && text.charCodeAt(pos + 1) === CharacterCodes.slash) {
+                let p = pos + 2;
+                let ch: number;
+                while (p < end) {
+                    ch = text.charCodeAt(p);
+                    if (!isIdentifierPart(ch, languageVersion) &&
+                        ch !== CharacterCodes.minus &&
+                        ch !== CharacterCodes.dot &&
+                        ch !== CharacterCodes.backslash) {
+                        break;
+                    }
+                    p++;
+                }
+                if (ch === CharacterCodes.greaterThan) {
+                    let tagName = text.substring(pos + 2, p).replace(/\s/g, '');
+                    if (!hasProperty(closingTags, tagName)) {
+                        closingTags[tagName] = [];
+                    }
+                    closingTags[tagName].push(pos);
+                    pos = p + 1;
+                } 
+            }
+            pos++;
+        }
+        return closingTags;
+    }
+ 
     // Creates a scanner over a (possibly unspecified) range of a piece of text.
     /* @internal */ 
     export function createScanner(languageVersion: ScriptTarget, skipTrivia: boolean, text?: string, onError?: ErrorCallback, start?: number, length?: number): Scanner {