build(awslint): Add RuleFilterSet class to cache include/exclude rules. (#27319)

Incremental fix to awslint performance. The `shouldEvaluate()` method is invoked for every context of every rule of every linter. The rule filter matching that was called from this method was iterating over the include/exclude list each time, and since we now have 2k+ rule filters, this was taking a long time( 55s for `aws-cdk-lib`).

This PR caches those rule filters and causes most lookups to be O(1), taking the evaluation time from 55s to 18ms. One minor limitation in the cache is that you can no longer use a 'startsWith' asterisk in the code portion of the filter, though you can still use an 'anyString' wildcard for the whole. This is explained better in the the comments:

```
  /**
   * Rule filter format is code:scope e.g. 'docs-public-apis:aws-cdk-lib.TagType'.
   * Wildcards can be used in the following ways:
   *
   * 1. Match any code e.g.: '*:aws-cdk-lib.TagType'
   * 2. Match any scope e.g.: 'docs-public-apis:*'
   * 3. Match any scope prefix e.g.: 'docs-public-apis:aws-cdk-lib.Tag*'
   */
```

----

*By submitting this pull request, I confirm that my contribution is made under the terms of the Apache-2.0 license*

Author: mikewrighton

packages/awslint/bin/awslint.ts

@@ -6,7 +6,7 @@ import * as chalk from 'chalk';
 import * as fs from 'fs-extra';
 import * as reflect from 'jsii-reflect';
 import * as yargs from 'yargs';
-import { ALL_RULES_LINTER, DiagnosticLevel } from '../lib';
+import { ALL_RULES_LINTER, DiagnosticLevel, RuleFilterSet } from '../lib';
 
 let stackTrace = false;
 
@@ -37,7 +37,7 @@ async function main() {
     .example('awslint', 'lints the current module against all rules')
     .example('awslint -v -i "resource*" -i "import*"', 'lints against all rules that start with "resource" or "import" and print successes')
     .example('awslint -x "*:@aws-cdk/aws-s3*"', 'evaluate all rules in all scopes besides ones that begin with "@aws-cdk/aws-s3"')
-    .example('awslint --save', 'updated "package.json" with "exclude"s for all failing rules');
+    .example('awslint --save', 'updated "awslint.json" with "exclude"s for all failing rules');
 
   if (!process.stdout.isTTY) {
     // Disable chalk color highlighting
@@ -118,11 +118,14 @@ async function main() {
     const excludesToSave = new Array<string>();
     let errors = 0;
 
+    const includeRules = new RuleFilterSet(args.include);
+    const excludeRules = new RuleFilterSet(args.exclude);
+
     const results = [];
 
     results.push(...ALL_RULES_LINTER.eval(assembly, {
-      include: args.include,
-      exclude: args.exclude,
+      includeRules: includeRules,
+      excludeRules: excludeRules,
     }));
 
     // Sort errors to the top (highest severity first)

packages/awslint/lib/index.ts

@@ -1,2 +1,3 @@
 export * from './linter';
 export * from './rules';
+export * from './rule-specs';

packages/awslint/lib/linter.ts

@@ -1,19 +1,20 @@
 import * as util from 'util';
 import { PrimitiveType } from '@jsii/spec';
 import * as reflect from 'jsii-reflect';
+import { RuleFilterSet } from './rule-specs';
 
 export interface LinterOptions {
   /**
    * List of rules to include.
    * @default all rules
    */
-  include?: string[];
+  includeRules?: RuleFilterSet;
 
   /**
    * List of rules to exclude (takes precedence on "include")
    * @default none
    */
-  exclude?: string[];
+  excludeRules?: RuleFilterSet;
 }
 
 export abstract class LinterBase {
@@ -222,47 +223,20 @@ export class Evaluation<T> {
    * Evaluates whether the rule should be evaluated based on the filters applied.
    */
   private shouldEvaluate(code: string, scope: string) {
-    if (!this.options.include || this.options.include.length === 0) {
+    if (!this.options.includeRules || this.options.includeRules.isEmpty()) {
       return true;
     }
 
-    for (const include of this.options.include) {
-      // match include
-      if (matchRule(include)) {
-        for (const exclude of this.options.exclude || []) {
-          // match exclude
-          if (matchRule(exclude)) {
-            return false;
-          }
-        }
-        return true;
+    if (this.options.includeRules.matches(code, scope)) {
+      if (this.options.excludeRules?.matches(code, scope)) {
+        return false;
       }
+      return true;
     }
 
     return false;
-
-    function matchRule(filter: string) {
-      if (filter.indexOf(':') === -1) {
-        filter += ':*'; // add "*" scope filter if there isn't one
-      }
-
-      // filter format is "code:scope" and both support "*" suffix to indicate startsWith
-      const [codeFilter, scopeFilter] = filter.split(':');
-      return matchPattern(code, codeFilter) && matchPattern(scope, scopeFilter);
-    }
-
-    function matchPattern(s: string, pattern: string) {
-      if (pattern.endsWith('*')) {
-        const prefix = pattern.slice(0, -1);
-        return s.startsWith(prefix);
-      } else {
-        return s === pattern;
-      }
-    }
   }
-
 }
-
 export interface Rule {
   code: string,
   message: string;

packages/awslint/lib/rule-specs.ts

@@ -0,0 +1,110 @@
+/**
+ * Caches the list of rule filters that are specified in the include and exclude options in awslint.json.
+ */
+export class RuleFilterSet {
+  /**
+   * Rule filter format is code:scope e.g. 'docs-public-apis:aws-cdk-lib.TagType'.
+   * Wildcards can be used in the following ways:
+   *
+   * 1. Match any code e.g.: '*:aws-cdk-lib.TagType'
+   * 2. Match any scope e.g.: 'docs-public-apis:*'
+   * 3. Match any scope prefix e.g.: 'docs-public-apis:aws-cdk-lib.Tag*'
+   */
+
+  private codesToScopes = new Map<string, Set<string>>(); // code -> list of scopes
+
+  private codesToScopePrefixes = new Map<string, Set<string>>(); // code -> list of scope prefixes (wildcards)
+
+  private scopes = new Set<string>(); // list of scopes with a wilcard code
+
+  private scopePrefixes = new Set<string>(); // list of scope prefixes with a wildcard code
+
+  private _isEmpty: boolean = false;
+
+  constructor(ruleFilterList: string[]) {
+    if (!ruleFilterList || ruleFilterList.length == 0) {
+      this._isEmpty = true;
+    }
+
+    for (var filter of ruleFilterList) {
+      if (filter.indexOf(':') === -1) {
+        filter += ':*'; // add "*" scope filter if there isn't one
+      }
+
+      const [code, scope] = filter.split(':');
+
+      if (this.hasWildcard(code)) {
+        if (code.length > 1) {
+          throw new Error(`Error parsing rule filter ${filter}: rule code can only be a single wildcard, or a complete string.`);
+        } else {
+          if (this.hasWildcard(scope)) {
+            this.scopePrefixes.add(scope);
+          } else {
+            this.scopes.add(scope);
+          }
+        }
+      } else {
+        if (this.hasWildcard(scope)) {
+          this.addToMap(this.codesToScopePrefixes, code, scope);
+        } else {
+          this.addToMap(this.codesToScopes, code, scope);
+        }
+      }
+    }
+  }
+
+  public matches(code: string, scope: string) {
+    // Check complete filter
+    const completeScopes = this.codesToScopes.get(code);
+    if (completeScopes && completeScopes.has(scope)) {
+      return true;
+    }
+
+    // Check if scope matches a prefix e.g. 'docs-public-apis:aws-cdk-lib.Tag*'
+    const scopePrefixesForCode = this.codesToScopePrefixes.get(code);
+    if (scopePrefixesForCode) {
+      if (this.containsPrefix(scopePrefixesForCode, scope)) {
+        return true;
+      }
+    }
+
+    // Check if scope has a wildcard code e.g. '*:aws-cdk-lib.TagType'
+    if (this.scopes.has(scope)) {
+      return true;
+    }
+
+    // Check if scope matches a prefix with a wildcard code e.g. '*:aws-cdk-lib.TagType*'
+    if (this.containsPrefix(this.scopePrefixes, scope)) {
+      return true;
+    }
+
+    return false;
+  }
+
+  private containsPrefix(prefixes: Set<string>, value: string) {
+    for (const prefix of prefixes) {
+      const prefixStr = prefix.slice(0, -1); // Strip the asterisk
+      if (value.startsWith(prefixStr)) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  public isEmpty() {
+    return this._isEmpty;
+  }
+
+  private addToMap(map: Map<string, Set<string>>, code: string, scope: string) {
+    if (!map.has(code)) {
+      map.set(code, new Set<string>());
+    }
+
+    map.get(code)?.add(scope);
+  }
+
+  private hasWildcard(value: string) {
+    return value.indexOf('*') !== -1;
+  }
+}