Issue 7181 - Keep a keyword-by-filter map after all

lib/matcher.js

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
  * Copyright (C) 2006-present eyeo GmbH
  *
  * Adblock Plus is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
  * published by the Free Software Foundation.
  *
  * Adblock Plus is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 137 matching lines @@
  */
 class Matcher
 {
   constructor()
   {
     /**
      * Lookup table for keywords by their associated filter
      * @type {Map.<RegExpFilter,string>}
      * @private
      */
-    this._keywordsByFilter = new Map();
+    this._keywordByFilter = new Map();
 
     /**
      * Lookup table for simple filters by their associated keyword
      * @type {Map.<string,(RegExpFilter|Set.<RegExpFilter>)>}
      * @private
      */
     this._simpleFiltersByKeyword = new Map();
 
     /**
      * Lookup table for complex filters by their associated keyword
      * @type {Map.<string,(RegExpFilter|Set.<RegExpFilter>)>}
      * @private
      */
     this._complexFiltersByKeyword = new Map();
 
     /**
      * Lookup table of type-specific lookup tables for complex filters by their
      * associated keyword
      * @type {Map.<string,Map.<string,(RegExpFilter|Set.<RegExpFilter>)>>}
      * @private
      */
     this._filterMapsByType = new Map();
   }
 
   /**
    * Removes all known filters
    */
   clear()
   {
-    this._keywordsByFilter.clear();
+    this._keywordByFilter.clear();
     this._simpleFiltersByKeyword.clear();
     this._complexFiltersByKeyword.clear();
     this._filterMapsByType.clear();
   }
 
   /**
    * Adds a filter to the matcher
    * @param {RegExpFilter} filter
    */
   add(filter)
   {
-    if (this._keywordsByFilter.has(filter))
+    if (this._keywordByFilter.has(filter))
       return;
 
     // Look for a suitable keyword
     let keyword = this.findKeyword(filter);
     let locationOnly = filter.isLocationOnly();
 
     addFilterByKeyword(filter, keyword,
                        locationOnly ? this._simpleFiltersByKeyword :
                          this._complexFiltersByKeyword);
 
-    this._keywordsByFilter.set(filter, keyword);
+    this._keywordByFilter.set(filter, keyword);
 
     if (locationOnly)
       return;
 
     for (let type of nonDefaultTypes(filter.contentType))
     {
       let map = this._filterMapsByType.get(type);
       if (!map)
         this._filterMapsByType.set(type, map = new Map());
 
       addFilterByKeyword(filter, keyword, map);
     }
   }
 
   /**
    * Removes a filter from the matcher
    * @param {RegExpFilter} filter
    */
   remove(filter)
   {
-    let keyword = this._keywordsByFilter.get(filter);
+    let keyword = this._keywordByFilter.get(filter);
     if (typeof keyword == "undefined")
       return;
 
     let locationOnly = filter.isLocationOnly();
 
     removeFilterByKeyword(filter, keyword,
                           locationOnly ? this._simpleFiltersByKeyword :
                             this._complexFiltersByKeyword);
 
-    this._keywordsByFilter.delete(filter);
+    this._keywordByFilter.delete(filter);
 
     if (locationOnly)
       return;
 
     for (let type of nonDefaultTypes(filter.contentType))
     {
       let map = this._filterMapsByType.get(type);
       if (map)
         removeFilterByKeyword(filter, keyword, map);
     }
@@ skipping 317 matching lines @@
 
 exports.CombinedMatcher = CombinedMatcher;
 
 /**
  * Shared {@link CombinedMatcher} instance that should usually be used.
  * @type {CombinedMatcher}
  */
 let defaultMatcher = new CombinedMatcher();
 
 exports.defaultMatcher = defaultMatcher;