awslint 2.97.1-alpha.0 → 2.99.0-alpha.0

package/bin/awslint.js

@@ -18,12 +18,12 @@ async function main() {
         .command('$0', 'lint the current module (default)')
         .command('list', 'list all available rules')
         .option('include', { alias: 'i', type: 'array', desc: 'evaluate only this rule(s)', default: ['*'] })
-        .option('exclude', { alias: 'x', type: 'array', desc: 'do not evaludate these rules (takes priority over --include)', default: [] })
-        .option('save', { type: 'boolean', desc: 'updates package.json with "exclude" statements for all failing rules', default: false })
+        .option('exclude', { alias: 'x', type: 'array', desc: 'do not evaluate these rules (takes priority over --include)', default: [] })
+        .option('save', { type: 'boolean', desc: 'updates package.json (or awslint.json if it exists) with "exclude" statements for all failing rules', default: false })
         .option('verbose', { alias: 'v', type: 'boolean', desc: 'verbose output (prints all assertions)', default: false })
         .option('quiet', { alias: 'q', type: 'boolean', desc: 'quiet mode - shows only errors', default: true })
         .option('force', { type: 'boolean', desc: 'succeed silently if this is not a jsii module', default: true })
-        .option('config', { type: 'boolean', desc: 'reads options from the "awslint" section in package.json', default: true })
+        .option('config', { type: 'boolean', desc: 'reads options from "awslint.json" if it exists, and otherwise from the "awslint" section in package.json', default: true })
         .option('debug', { type: 'boolean', desc: 'debug output', default: false })
         .option('compile', { alias: 'c', type: 'boolean', desc: 'always run the jsii compiler (use "--no-compile" to never run the compiler, even if .jsii doesn\'t exist)' })
         .group('include', 'Filtering')
@@ -50,7 +50,8 @@ async function main() {
     }
     const command = args._[0] || 'lint';
     const workdir = process.cwd();
-    const config = path.join(workdir, 'package.json');
+    const pkgConfig = path.join(workdir, 'package.json');
+    const awslintConfig = path.join(workdir, 'awslint.json');
     if (command === 'list') {
         for (const rule of lib_1.ALL_RULES_LINTER.rules) {
             console.info(`${chalk.cyan(rule.code)}: ${rule.message}`);
@@ -58,10 +59,10 @@ async function main() {
         return;
     }
     // if no package.json and force is true (default), just don't do anything
-    if (!await fs.pathExists(config) && args.force) {
+    if (!await fs.pathExists(pkgConfig) && args.force) {
         return;
     }
-    const pkg = await fs.readJSON(config);
+    const pkg = await fs.readJSON(pkgConfig);
     // if this is not a jsii module we have nothing to look for
     if (!pkg.jsii) {
         if (args.force) {
@@ -74,9 +75,19 @@ async function main() {
     if (await shouldCompile()) {
         await shell('jsii');
     }
+    // awslint.json takes precedence over package.json for awslint options.
+    const standloneOptions = await readStandaloneOptions(awslintConfig);
     // read "awslint" from package.json
     if (args.config) {
-        mergeOptions(args, pkg.awslint);
+        if (standloneOptions) {
+            if (pkg.awslint) {
+                console.warn('awslint options in package.json will be ignored since awslint.json exists.');
+            }
+            mergeOptions(args, standloneOptions);
+        }
+        else {
+            mergeOptions(args, pkg.awslint);
+        }
     }
     if (args.debug) {
         console.error('command: ' + command);
@@ -129,20 +140,36 @@ async function main() {
             }
         }
         if (excludesToSave.length > 0) {
-            if (!pkg.awslint) {
-                pkg.awslint = {};
+            if (standloneOptions) {
+                if (!standloneOptions.exclude) {
+                    standloneOptions.exclude = [];
+                }
             }
-            if (!pkg.awslint.exclude) {
-                pkg.awslint.exclude = [];
+            else {
+                if (!pkg.awslint) {
+                    pkg.awslint = {};
+                }
+                if (!pkg.awslint.exclude) {
+                    pkg.awslint.exclude = [];
+                }
             }
-            const excludes = pkg.awslint.exclude;
+            const excludes = standloneOptions ? standloneOptions.exclude : pkg.awslint.exclude;
             for (const exclude of excludesToSave) {
                 if (excludes.indexOf(exclude) === -1) {
                     excludes.push(exclude);
                 }
             }
             if (excludes.length > 0) {
-                await fs.writeJSON(config, pkg, { spaces: 2 });
+                if (standloneOptions) {
+                    // If awslint.json exists, write the excludes there instead of the old package.json (legacy format).
+                    if (pkg.awslint) {
+                        console.warn('Excludes will be written to awslint.json.');
+                    }
+                    await fs.writeJSON(awslintConfig, standloneOptions, { spaces: 2 });
+                }
+                else {
+                    await fs.writeJSON(pkgConfig, pkg, { spaces: 2 });
+                }
             }
         }
         if (errors && !args.save) {
@@ -206,6 +233,13 @@ function mergeOptions(dest, pkg) {
     }
     return dest;
 }
+async function readStandaloneOptions(awslintConfig) {
+    if (!await fs.pathExists(awslintConfig)) {
+        return;
+    }
+    const options = await fs.readJSON(awslintConfig);
+    return options;
+}
 async function shell(command) {
     const child = child_process.spawn(command, [], { stdio: ['inherit', 'inherit', 'inherit'] });
     return new Promise((ok, ko) => {
@@ -220,4 +254,4 @@ async function shell(command) {
         child.once('error', ko);
     });
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"awslint.js","sourceRoot":"","sources":["awslint.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable max-len */\n/* eslint-disable no-console */\nimport * as child_process from 'child_process';\nimport * as path from 'path';\nimport * as chalk from 'chalk';\nimport * as fs from 'fs-extra';\nimport * as reflect from 'jsii-reflect';\nimport * as yargs from 'yargs';\nimport { ALL_RULES_LINTER, DiagnosticLevel } from '../lib';\n\nlet stackTrace = false;\n\nasync function main() {\n  const argv = yargs\n    .env('AWSLINT')\n    .usage('awslint [options] [command]')\n    .showHelpOnFail(true)\n    .command('$0', 'lint the current module (default)')\n    .command('list', 'list all available rules')\n    .option('include', { alias: 'i', type: 'array', desc: 'evaluate only this rule(s)', default: ['*'] })\n    .option('exclude', { alias: 'x', type: 'array', desc: 'do not evaludate these rules (takes priority over --include)', default: [] })\n    .option('save', { type: 'boolean', desc: 'updates package.json with \"exclude\" statements for all failing rules', default: false })\n    .option('verbose', { alias: 'v', type: 'boolean', desc: 'verbose output (prints all assertions)', default: false })\n    .option('quiet', { alias: 'q', type: 'boolean', desc: 'quiet mode - shows only errors', default: true })\n    .option('force', { type: 'boolean', desc: 'succeed silently if this is not a jsii module', default: true })\n    .option('config', { type: 'boolean', desc: 'reads options from the \"awslint\" section in package.json', default: true })\n    .option('debug', { type: 'boolean', desc: 'debug output', default: false })\n    .option('compile', { alias: 'c', type: 'boolean', desc: 'always run the jsii compiler (use \"--no-compile\" to never run the compiler, even if .jsii doesn\\'t exist)' })\n    .group('include', 'Filtering')\n    .group('exclude', 'Filtering')\n    .group('config', 'Configuration')\n    .group('save', 'Configuration')\n    .group('verbose', 'Output')\n    .group('quiet', 'Output')\n    .group('debug', 'Output')\n    .group('compile', 'Build')\n    .example('awslint', 'lints the current module against all rules')\n    .example('awslint -v -i \"resource*\" -i \"import*\"', 'lints against all rules that start with \"resource\" or \"import\" and print successes')\n    .example('awslint -x \"*:@aws-cdk/aws-s3*\"', 'evaluate all rules in all scopes besides ones that begin with \"@aws-cdk/aws-s3\"')\n    .example('awslint --save', 'updated \"package.json\" with \"exclude\"s for all failing rules');\n\n  if (!process.stdout.isTTY) {\n    // Disable chalk color highlighting\n    process.env.FORCE_COLOR = '0';\n  }\n\n  const args = argv.argv;\n\n  stackTrace = args.verbose || args.debug;\n\n  if (args._.length > 1) {\n    argv.showHelp();\n    process.exit(1);\n  }\n\n  const command = args._[0] || 'lint';\n  const workdir = process.cwd();\n\n  const config = path.join(workdir, 'package.json');\n\n  if (command === 'list') {\n    for (const rule of ALL_RULES_LINTER.rules) {\n      console.info(`${chalk.cyan(rule.code)}: ${rule.message}`);\n    }\n    return;\n  }\n\n  // if no package.json and force is true (default), just don't do anything\n  if (!await fs.pathExists(config) && args.force) {\n    return;\n  }\n\n  const pkg = await fs.readJSON(config);\n\n  // if this is not a jsii module we have nothing to look for\n  if (!pkg.jsii) {\n    if (args.force) {\n      return; // just silently succeed\n    }\n\n    throw new Error(`Module in ${workdir} is not a jsii module (no \"jsii\" section in package.json)`);\n  }\n\n  // if package.json contains a `jsii` section but there is no .jsii file\n  // it means we haven't compiled the module.\n  if (await shouldCompile()) {\n    await shell('jsii');\n  }\n\n  // read \"awslint\" from package.json\n  if (args.config) {\n    mergeOptions(args, pkg.awslint);\n  }\n\n  if (args.debug) {\n    console.error('command: ' + command);\n    console.error('options: ' + JSON.stringify(args, undefined, 2));\n  }\n\n  if (command === 'lint') {\n    const assembly = await loadModule(workdir);\n    if (!assembly) {\n      return;\n    }\n\n    const excludesToSave = new Array<string>();\n    let errors = 0;\n\n    const results = [];\n\n    results.push(...ALL_RULES_LINTER.eval(assembly, {\n      include: args.include,\n      exclude: args.exclude,\n    }));\n\n    // Sort errors to the top (highest severity first)\n    results.sort((a, b) => b.level - a.level);\n\n    // process results\n\n    for (const diag of results) {\n      const suppressionKey = `${diag.rule.code}:${diag.scope}`;\n\n      let color;\n      switch (diag.level) {\n        case DiagnosticLevel.Success:\n          if (args.verbose) {\n            color = chalk.gray;\n          }\n          break;\n        case DiagnosticLevel.Error:\n          errors++;\n          color = chalk.red;\n          if (args.save) {\n            excludesToSave.push(suppressionKey);\n          }\n          break;\n        case DiagnosticLevel.Warning:\n          if (!args.quiet) {\n            color = chalk.yellow;\n          }\n          break;\n        case DiagnosticLevel.Skipped:\n          if (!args.quiet) {\n            color = chalk.blue;\n          }\n          break;\n      }\n\n      if (color) {\n        console.error(color(`${DiagnosticLevel[diag.level].toLowerCase()}: [${chalk.bold(`awslint:${diag.rule.code}`)}:${chalk.bold(diag.scope)}] ${diag.message}`));\n      }\n    }\n\n    if (excludesToSave.length > 0) {\n      if (!pkg.awslint) {\n        pkg.awslint = { };\n      }\n\n      if (!pkg.awslint.exclude) {\n        pkg.awslint.exclude = [];\n      }\n\n      const excludes: string[] = pkg.awslint.exclude;\n\n      for (const exclude of excludesToSave) {\n        if (excludes.indexOf(exclude) === -1) {\n          excludes.push(exclude);\n        }\n      }\n\n      if (excludes.length > 0) {\n        await fs.writeJSON(config, pkg, { spaces: 2 });\n      }\n    }\n\n    if (errors && !args.save) {\n      process.exit(1);\n    }\n\n    return;\n  }\n\n  argv.showHelp();\n  throw new Error(`Invalid command: ${command}`);\n\n  async function shouldCompile() {\n\n    // if --compile is explicitly enabled then just compile always\n    if (args.compile === true) {\n      return true;\n    }\n\n    // if we have a .jsii file and we are not forced to compile, then don't compile\n    if (await fs.pathExists(path.join(workdir, '.jsii'))) {\n      return false;\n    }\n\n    // we don't have a .jsii file, and --no-compile is explicily set, then it's an error\n    if (args.compile === false) {\n      throw new Error('No .jsii file and --no-compile is set');\n    }\n\n    // compile!\n    return true;\n  }\n\n}\n\nmain().catch(e => {\n  console.error(chalk.red(e.message));\n  if (stackTrace) {\n    console.error(e.stack);\n  }\n  process.exit(1);\n});\n\nasync function loadModule(dir: string) {\n  const ts = new reflect.TypeSystem();\n  await ts.load(dir, { validate: false }); // Don't validate to save 66% of execution time (20s vs 1min).\n  // We run 'awslint' during build time, assemblies are guaranteed to be ok.\n\n  if (ts.roots.length !== 1) {\n    throw new Error('Expecting only a single root assembly');\n  }\n\n  return ts.roots[0];\n}\n\nfunction mergeOptions(dest: any, pkg?: any) {\n  if (!pkg) { return; } // no options in package.json\n\n  for (const [key, value] of Object.entries(pkg)) {\n\n    // if this is an array option, then add values to destination\n    if (Array.isArray(value)) {\n      const arr = dest[key] || [];\n      arr.push(...value);\n      dest[key] = arr;\n      continue;\n    }\n\n    // objects are not allowed\n    if (typeof value === 'object') {\n      throw new Error(`Invalid option \"${key}\" in package.json: ${JSON.stringify(value)}`);\n    }\n\n    // primitives simply override\n    dest[key] = value;\n  }\n\n  return dest;\n}\n\nasync function shell(command: string) {\n  const child = child_process.spawn(command, [], { stdio: ['inherit', 'inherit', 'inherit'] });\n  return new Promise<void>((ok, ko) => {\n    child.once('exit', (status: any) => {\n      if (status === 0) {\n        return ok();\n      } else {\n        return ko(new Error(`${command} exited with status ${status}`));\n      }\n    });\n    child.once('error', ko);\n  });\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"awslint.js","sourceRoot":"","sources":["awslint.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable max-len */\n/* eslint-disable no-console */\nimport * as child_process from 'child_process';\nimport * as path from 'path';\nimport * as chalk from 'chalk';\nimport * as fs from 'fs-extra';\nimport * as reflect from 'jsii-reflect';\nimport * as yargs from 'yargs';\nimport { ALL_RULES_LINTER, DiagnosticLevel } from '../lib';\n\nlet stackTrace = false;\n\nasync function main() {\n  const argv = yargs\n    .env('AWSLINT')\n    .usage('awslint [options] [command]')\n    .showHelpOnFail(true)\n    .command('$0', 'lint the current module (default)')\n    .command('list', 'list all available rules')\n    .option('include', { alias: 'i', type: 'array', desc: 'evaluate only this rule(s)', default: ['*'] })\n    .option('exclude', { alias: 'x', type: 'array', desc: 'do not evaluate these rules (takes priority over --include)', default: [] })\n    .option('save', { type: 'boolean', desc: 'updates package.json (or awslint.json if it exists) with \"exclude\" statements for all failing rules', default: false })\n    .option('verbose', { alias: 'v', type: 'boolean', desc: 'verbose output (prints all assertions)', default: false })\n    .option('quiet', { alias: 'q', type: 'boolean', desc: 'quiet mode - shows only errors', default: true })\n    .option('force', { type: 'boolean', desc: 'succeed silently if this is not a jsii module', default: true })\n    .option('config', { type: 'boolean', desc: 'reads options from \"awslint.json\" if it exists, and otherwise from the \"awslint\" section in package.json', default: true })\n    .option('debug', { type: 'boolean', desc: 'debug output', default: false })\n    .option('compile', { alias: 'c', type: 'boolean', desc: 'always run the jsii compiler (use \"--no-compile\" to never run the compiler, even if .jsii doesn\\'t exist)' })\n    .group('include', 'Filtering')\n    .group('exclude', 'Filtering')\n    .group('config', 'Configuration')\n    .group('save', 'Configuration')\n    .group('verbose', 'Output')\n    .group('quiet', 'Output')\n    .group('debug', 'Output')\n    .group('compile', 'Build')\n    .example('awslint', 'lints the current module against all rules')\n    .example('awslint -v -i \"resource*\" -i \"import*\"', 'lints against all rules that start with \"resource\" or \"import\" and print successes')\n    .example('awslint -x \"*:@aws-cdk/aws-s3*\"', 'evaluate all rules in all scopes besides ones that begin with \"@aws-cdk/aws-s3\"')\n    .example('awslint --save', 'updated \"package.json\" with \"exclude\"s for all failing rules');\n\n  if (!process.stdout.isTTY) {\n    // Disable chalk color highlighting\n    process.env.FORCE_COLOR = '0';\n  }\n\n  const args = argv.argv;\n\n  stackTrace = args.verbose || args.debug;\n\n  if (args._.length > 1) {\n    argv.showHelp();\n    process.exit(1);\n  }\n\n  const command = args._[0] || 'lint';\n  const workdir = process.cwd();\n\n  const pkgConfig = path.join(workdir, 'package.json');\n  const awslintConfig = path.join(workdir, 'awslint.json');\n\n  if (command === 'list') {\n    for (const rule of ALL_RULES_LINTER.rules) {\n      console.info(`${chalk.cyan(rule.code)}: ${rule.message}`);\n    }\n    return;\n  }\n\n  // if no package.json and force is true (default), just don't do anything\n  if (!await fs.pathExists(pkgConfig) && args.force) {\n    return;\n  }\n\n  const pkg = await fs.readJSON(pkgConfig);\n\n  // if this is not a jsii module we have nothing to look for\n  if (!pkg.jsii) {\n    if (args.force) {\n      return; // just silently succeed\n    }\n\n    throw new Error(`Module in ${workdir} is not a jsii module (no \"jsii\" section in package.json)`);\n  }\n\n  // if package.json contains a `jsii` section but there is no .jsii file\n  // it means we haven't compiled the module.\n  if (await shouldCompile()) {\n    await shell('jsii');\n  }\n\n  // awslint.json takes precedence over package.json for awslint options.\n  const standloneOptions = await readStandaloneOptions(awslintConfig);\n\n  // read \"awslint\" from package.json\n  if (args.config) {\n    if (standloneOptions) {\n      if (pkg.awslint) {\n        console.warn('awslint options in package.json will be ignored since awslint.json exists.');\n      }\n      mergeOptions(args, standloneOptions);\n    } else {\n      mergeOptions(args, pkg.awslint);\n    }\n  }\n\n\n  if (args.debug) {\n    console.error('command: ' + command);\n    console.error('options: ' + JSON.stringify(args, undefined, 2));\n  }\n\n  if (command === 'lint') {\n    const assembly = await loadModule(workdir);\n    if (!assembly) {\n      return;\n    }\n\n    const excludesToSave = new Array<string>();\n    let errors = 0;\n\n    const results = [];\n\n    results.push(...ALL_RULES_LINTER.eval(assembly, {\n      include: args.include,\n      exclude: args.exclude,\n    }));\n\n    // Sort errors to the top (highest severity first)\n    results.sort((a, b) => b.level - a.level);\n\n    // process results\n\n    for (const diag of results) {\n      const suppressionKey = `${diag.rule.code}:${diag.scope}`;\n\n      let color;\n      switch (diag.level) {\n        case DiagnosticLevel.Success:\n          if (args.verbose) {\n            color = chalk.gray;\n          }\n          break;\n        case DiagnosticLevel.Error:\n          errors++;\n          color = chalk.red;\n          if (args.save) {\n            excludesToSave.push(suppressionKey);\n          }\n          break;\n        case DiagnosticLevel.Warning:\n          if (!args.quiet) {\n            color = chalk.yellow;\n          }\n          break;\n        case DiagnosticLevel.Skipped:\n          if (!args.quiet) {\n            color = chalk.blue;\n          }\n          break;\n      }\n\n      if (color) {\n        console.error(color(`${DiagnosticLevel[diag.level].toLowerCase()}: [${chalk.bold(`awslint:${diag.rule.code}`)}:${chalk.bold(diag.scope)}] ${diag.message}`));\n      }\n    }\n\n    if (excludesToSave.length > 0) {\n      if (standloneOptions) {\n        if (!standloneOptions.exclude) {\n          standloneOptions.exclude = [];\n        }\n      } else {\n        if (!pkg.awslint) {\n          pkg.awslint = { };\n        }\n\n        if (!pkg.awslint.exclude) {\n          pkg.awslint.exclude = [];\n        }\n      }\n\n      const excludes: string[] = standloneOptions ? standloneOptions.exclude : pkg.awslint.exclude;\n\n      for (const exclude of excludesToSave) {\n        if (excludes.indexOf(exclude) === -1) {\n          excludes.push(exclude);\n        }\n      }\n\n      if (excludes.length > 0) {\n        if (standloneOptions) {\n          // If awslint.json exists, write the excludes there instead of the old package.json (legacy format).\n          if (pkg.awslint) {\n            console.warn('Excludes will be written to awslint.json.');\n          }\n          await fs.writeJSON(awslintConfig, standloneOptions, { spaces: 2 });\n        } else {\n          await fs.writeJSON(pkgConfig, pkg, { spaces: 2 });\n        }\n      }\n    }\n\n    if (errors && !args.save) {\n      process.exit(1);\n    }\n\n    return;\n  }\n\n  argv.showHelp();\n  throw new Error(`Invalid command: ${command}`);\n\n  async function shouldCompile() {\n\n    // if --compile is explicitly enabled then just compile always\n    if (args.compile === true) {\n      return true;\n    }\n\n    // if we have a .jsii file and we are not forced to compile, then don't compile\n    if (await fs.pathExists(path.join(workdir, '.jsii'))) {\n      return false;\n    }\n\n    // we don't have a .jsii file, and --no-compile is explicily set, then it's an error\n    if (args.compile === false) {\n      throw new Error('No .jsii file and --no-compile is set');\n    }\n\n    // compile!\n    return true;\n  }\n\n}\n\nmain().catch(e => {\n  console.error(chalk.red(e.message));\n  if (stackTrace) {\n    console.error(e.stack);\n  }\n  process.exit(1);\n});\n\nasync function loadModule(dir: string) {\n  const ts = new reflect.TypeSystem();\n  await ts.load(dir, { validate: false }); // Don't validate to save 66% of execution time (20s vs 1min).\n  // We run 'awslint' during build time, assemblies are guaranteed to be ok.\n\n  if (ts.roots.length !== 1) {\n    throw new Error('Expecting only a single root assembly');\n  }\n\n  return ts.roots[0];\n}\n\nfunction mergeOptions(dest: any, pkg?: any) {\n  if (!pkg) { return; } // no options in package.json\n\n  for (const [key, value] of Object.entries(pkg)) {\n\n    // if this is an array option, then add values to destination\n    if (Array.isArray(value)) {\n      const arr = dest[key] || [];\n      arr.push(...value);\n      dest[key] = arr;\n      continue;\n    }\n\n    // objects are not allowed\n    if (typeof value === 'object') {\n      throw new Error(`Invalid option \"${key}\" in package.json: ${JSON.stringify(value)}`);\n    }\n\n    // primitives simply override\n    dest[key] = value;\n  }\n\n  return dest;\n}\n\nasync function readStandaloneOptions(awslintConfig: string) {\n  if (!await fs.pathExists(awslintConfig)) {\n    return;\n  }\n\n  const options = await fs.readJSON(awslintConfig);\n  return options;\n}\n\nasync function shell(command: string) {\n  const child = child_process.spawn(command, [], { stdio: ['inherit', 'inherit', 'inherit'] });\n  return new Promise<void>((ok, ko) => {\n    child.once('exit', (status: any) => {\n      if (status === 0) {\n        return ok();\n      } else {\n        return ko(new Error(`${command} exited with status ${status}`));\n      }\n    });\n    child.once('error', ko);\n  });\n}\n"]}

package/bin/awslint.ts

@@ -18,12 +18,12 @@ async function main() {
     .command('$0', 'lint the current module (default)')
     .command('list', 'list all available rules')
     .option('include', { alias: 'i', type: 'array', desc: 'evaluate only this rule(s)', default: ['*'] })
-    .option('exclude', { alias: 'x', type: 'array', desc: 'do not evaludate these rules (takes priority over --include)', default: [] })
-    .option('save', { type: 'boolean', desc: 'updates package.json with "exclude" statements for all failing rules', default: false })
+    .option('exclude', { alias: 'x', type: 'array', desc: 'do not evaluate these rules (takes priority over --include)', default: [] })
+    .option('save', { type: 'boolean', desc: 'updates package.json (or awslint.json if it exists) with "exclude" statements for all failing rules', default: false })
     .option('verbose', { alias: 'v', type: 'boolean', desc: 'verbose output (prints all assertions)', default: false })
     .option('quiet', { alias: 'q', type: 'boolean', desc: 'quiet mode - shows only errors', default: true })
     .option('force', { type: 'boolean', desc: 'succeed silently if this is not a jsii module', default: true })
-    .option('config', { type: 'boolean', desc: 'reads options from the "awslint" section in package.json', default: true })
+    .option('config', { type: 'boolean', desc: 'reads options from "awslint.json" if it exists, and otherwise from the "awslint" section in package.json', default: true })
     .option('debug', { type: 'boolean', desc: 'debug output', default: false })
     .option('compile', { alias: 'c', type: 'boolean', desc: 'always run the jsii compiler (use "--no-compile" to never run the compiler, even if .jsii doesn\'t exist)' })
     .group('include', 'Filtering')
@@ -56,7 +56,8 @@ async function main() {
   const command = args._[0] || 'lint';
   const workdir = process.cwd();
 
-  const config = path.join(workdir, 'package.json');
+  const pkgConfig = path.join(workdir, 'package.json');
+  const awslintConfig = path.join(workdir, 'awslint.json');
 
   if (command === 'list') {
     for (const rule of ALL_RULES_LINTER.rules) {
@@ -66,11 +67,11 @@ async function main() {
   }
 
   // if no package.json and force is true (default), just don't do anything
-  if (!await fs.pathExists(config) && args.force) {
+  if (!await fs.pathExists(pkgConfig) && args.force) {
     return;
   }
 
-  const pkg = await fs.readJSON(config);
+  const pkg = await fs.readJSON(pkgConfig);
 
   // if this is not a jsii module we have nothing to look for
   if (!pkg.jsii) {
@@ -87,11 +88,22 @@ async function main() {
     await shell('jsii');
   }
 
+  // awslint.json takes precedence over package.json for awslint options.
+  const standloneOptions = await readStandaloneOptions(awslintConfig);
+
   // read "awslint" from package.json
   if (args.config) {
-    mergeOptions(args, pkg.awslint);
+    if (standloneOptions) {
+      if (pkg.awslint) {
+        console.warn('awslint options in package.json will be ignored since awslint.json exists.');
+      }
+      mergeOptions(args, standloneOptions);
+    } else {
+      mergeOptions(args, pkg.awslint);
+    }
   }
 
+
   if (args.debug) {
     console.error('command: ' + command);
     console.error('options: ' + JSON.stringify(args, undefined, 2));
@@ -153,15 +165,21 @@ async function main() {
     }
 
     if (excludesToSave.length > 0) {
-      if (!pkg.awslint) {
-        pkg.awslint = { };
-      }
+      if (standloneOptions) {
+        if (!standloneOptions.exclude) {
+          standloneOptions.exclude = [];
+        }
+      } else {
+        if (!pkg.awslint) {
+          pkg.awslint = { };
+        }
 
-      if (!pkg.awslint.exclude) {
-        pkg.awslint.exclude = [];
+        if (!pkg.awslint.exclude) {
+          pkg.awslint.exclude = [];
+        }
       }
 
-      const excludes: string[] = pkg.awslint.exclude;
+      const excludes: string[] = standloneOptions ? standloneOptions.exclude : pkg.awslint.exclude;
 
       for (const exclude of excludesToSave) {
         if (excludes.indexOf(exclude) === -1) {
@@ -170,7 +188,15 @@ async function main() {
       }
 
       if (excludes.length > 0) {
-        await fs.writeJSON(config, pkg, { spaces: 2 });
+        if (standloneOptions) {
+          // If awslint.json exists, write the excludes there instead of the old package.json (legacy format).
+          if (pkg.awslint) {
+            console.warn('Excludes will be written to awslint.json.');
+          }
+          await fs.writeJSON(awslintConfig, standloneOptions, { spaces: 2 });
+        } else {
+          await fs.writeJSON(pkgConfig, pkg, { spaces: 2 });
+        }
       }
     }
 
@@ -252,6 +278,15 @@ function mergeOptions(dest: any, pkg?: any) {
   return dest;
 }
 
+async function readStandaloneOptions(awslintConfig: string) {
+  if (!await fs.pathExists(awslintConfig)) {
+    return;
+  }
+
+  const options = await fs.readJSON(awslintConfig);
+  return options;
+}
+
 async function shell(command: string) {
   const child = child_process.spawn(command, [], { stdio: ['inherit', 'inherit', 'inherit'] });
   return new Promise<void>((ok, ko) => {

package/lib/rules/cfn-resource.js

@@ -5,9 +5,23 @@ const camelcase = require("camelcase");
 const core_types_1 = require("./core-types");
 const resource_1 = require("./resource");
 const linter_1 = require("../linter");
+const cfnResourceTagName = 'cloudformationResource';
 // this linter verifies that we have L2 coverage. it finds all "Cfn" classes and verifies
 // that we have a corresponding L1 class for it that's identified as a resource.
 exports.cfnResourceLinter = new linter_1.Linter(a => CfnResourceReflection.findAll(a));
+// Cache L1 constructs per type system.
+const l1ConstructCache = new Map();
+function cacheL1ConstructsForTypeSystem(sys) {
+    if (!l1ConstructCache.has(sys)) {
+        l1ConstructCache.set(sys, new Map());
+        for (const cls of sys.classes) {
+            const cfnResourceTag = cls.docs.customTag(cfnResourceTagName);
+            if (cfnResourceTag) {
+                l1ConstructCache.get(sys)?.set(cfnResourceTag?.toLocaleLowerCase(), cls);
+            }
+        }
+    }
+}
 exports.cfnResourceLinter.add({
     code: 'resource-class',
     message: 'every resource must have a resource class (L2), add \'@resource %s\' to its docstring',
@@ -23,10 +37,12 @@ class CfnResourceReflection {
      * @param fullName first two components are case-insensitive (e.g. `aws::s3::Bucket` is equivalent to `Aws::S3::Bucket`)
      */
     static findByName(sys, fullName) {
-        for (const cls of sys.classes) {
-            if (cls.docs.customTag('cloudformationResource')?.toLocaleLowerCase() === fullName.toLocaleLowerCase()) {
-                return new CfnResourceReflection(cls);
-            }
+        if (!l1ConstructCache.has(sys)) {
+            cacheL1ConstructsForTypeSystem(sys);
+        }
+        const cls = l1ConstructCache.get(sys)?.get(fullName.toLowerCase());
+        if (cls) {
+            return new CfnResourceReflection(cls);
         }
         return undefined;
     }
@@ -34,17 +50,14 @@ class CfnResourceReflection {
      * Returns all CFN resource classes within an assembly.
      */
     static findAll(assembly) {
-        return assembly.classes
+        return assembly.allClasses
             .filter(c => core_types_1.CoreTypes.isCfnResource(c))
             .map(c => new CfnResourceReflection(c));
     }
     constructor(cls) {
         this.classType = cls;
         this.basename = cls.name.slice('Cfn'.length);
-        // HACK: extract full CFN name from initializer docs
-        const initializerDoc = (cls.initializer && cls.initializer.docs.docs.summary) || '';
-        const out = /a new `([^`]+)`/.exec(initializerDoc);
-        const fullname = out && out[1];
+        const fullname = cls.docs.customTag('cloudformationResource');
         if (!fullname) {
             throw new Error(`Unable to extract CloudFormation resource name from initializer documentation of ${cls}`);
         }
@@ -65,4 +78,4 @@ class CfnResourceReflection {
     }
 }
 exports.CfnResourceReflection = CfnResourceReflection;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2ZuLXJlc291cmNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiY2ZuLXJlc291cmNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLHVDQUF1QztBQUV2Qyw2Q0FBeUM7QUFDekMseUNBQWdEO0FBQ2hELHNDQUFtQztBQUVuQyx5RkFBeUY7QUFDekYsZ0ZBQWdGO0FBQ25FLFFBQUEsaUJBQWlCLEdBQUcsSUFBSSxlQUFNLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxxQkFBcUIsQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztBQUVuRix5QkFBaUIsQ0FBQyxHQUFHLENBQUM7SUFDcEIsSUFBSSxFQUFFLGdCQUFnQjtJQUN0QixPQUFPLEVBQUUsdUZBQXVGO0lBQ2hHLE9BQU8sRUFBRSxJQUFJO0lBQ2IsSUFBSSxFQUFFLENBQUMsQ0FBQyxFQUFFO1FBQ1IsTUFBTSxFQUFFLEdBQUcsNkJBQWtCLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxHQUFHLENBQUMsU0FBUyxDQUFDLFFBQVEsQ0FBQyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxHQUFHLENBQUMsUUFBUSxLQUFLLENBQUMsQ0FBQyxHQUFHLENBQUMsUUFBUSxDQUFDLENBQUM7UUFDN0csQ0FBQyxDQUFDLE1BQU0sQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxRQUFRLEVBQUUsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxRQUFRLENBQUMsQ0FBQztJQUMvQyxDQUFDO0NBQ0YsQ0FBQyxDQUFDO0FBRUgsTUFBYSxxQkFBcUI7SUFDaEM7OztPQUdHO0lBQ0ksTUFBTSxDQUFDLFVBQVUsQ0FBQyxHQUF1QixFQUFFLFFBQWdCO1FBQ2hFLEtBQUssTUFBTSxHQUFHLElBQUksR0FBRyxDQUFDLE9BQU8sRUFBRTtZQUM3QixJQUFJLEdBQUcsQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLHdCQUF3QixDQUFDLEVBQUUsaUJBQWlCLEVBQUUsS0FBSyxRQUFRLENBQUMsaUJBQWlCLEVBQUUsRUFBRTtnQkFDdEcsT0FBTyxJQUFJLHFCQUFxQixDQUFDLEdBQUcsQ0FBQyxDQUFDO2FBQ3ZDO1NBQ0Y7UUFFRCxPQUFPLFNBQVMsQ0FBQztJQUNuQixDQUFDO0lBRUQ7O09BRUc7SUFDSSxNQUFNLENBQUMsT0FBTyxDQUFDLFFBQTBCO1FBQzlDLE9BQU8sUUFBUSxDQUFDLE9BQU87YUFDcEIsTUFBTSxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsc0JBQVMsQ0FBQyxhQUFhLENBQUMsQ0FBQyxDQUFDLENBQUM7YUFDdkMsR0FBRyxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsSUFBSSxxQkFBcUIsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO0lBQzVDLENBQUM7SUFTRCxZQUFZLEdBQXNCO1FBQ2hDLElBQUksQ0FBQyxTQUFTLEdBQUcsR0FBRyxDQUFDO1FBRXJCLElBQUksQ0FBQyxRQUFRLEdBQUcsR0FBRyxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsS0FBSyxDQUFDLE1BQU0sQ0FBQyxDQUFDO1FBRTdDLG9EQUFvRDtRQUNwRCxNQUFNLGNBQWMsR0FBRyxDQUFDLEdBQUcsQ0FBQyxXQUFXLElBQUksR0FBRyxDQUFDLFdBQVcsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxJQUFJLEVBQUUsQ0FBQztRQUNwRixNQUFNLEdBQUcsR0FBRyxpQkFBaUIsQ0FBQyxJQUFJLENBQUMsY0FBYyxDQUFDLENBQUM7UUFDbkQsTUFBTSxRQUFRLEdBQUcsR0FBRyxJQUFJLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQztRQUMvQixJQUFJLENBQUMsUUFBUSxFQUFFO1lBQ2IsTUFBTSxJQUFJLEtBQUssQ0FBQyxvRkFBb0YsR0FBRyxFQUFFLENBQUMsQ0FBQztTQUM1RztRQUVELElBQUksQ0FBQyxRQUFRLEdBQUcsUUFBUSxDQUFDO1FBRXpCLElBQUksQ0FBQyxTQUFTLEdBQUcsUUFBUSxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsQ0FBQyxLQUFLLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUU3RCxJQUFJLENBQUMsY0FBYyxHQUFHLEdBQUcsQ0FBQyxhQUFhO2FBQ3BDLE1BQU0sQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsTUFBTSxJQUFJLEVBQUUsQ0FBQyxDQUFDLHVCQUF1QixDQUFDO2FBQy9ELEdBQUcsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLHlCQUF5QixDQUFDLElBQUksU0FBUyxDQUFDO2FBQ2xFLEdBQUcsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLElBQUksQ0FBQyxnQ0FBZ0MsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO1FBRXRELElBQUksQ0FBQyxHQUFHLEdBQUcsR0FBRyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsR0FBRyxJQUFJLEVBQUUsQ0FBQztJQUNyQyxDQUFDO0lBRU8sZ0NBQWdDLENBQUMsSUFBWTtRQUVuRCxvRUFBb0U7UUFDcEUsSUFBSSxJQUFJLENBQUMsUUFBUSxLQUFLLGVBQWUsSUFBSSxJQUFJLEtBQUssU0FBUyxFQUFFO1lBQzNELE9BQU8sSUFBSSxDQUFDO1NBQ2I7UUFFRCxPQUFPLFNBQVMsQ0FBQyxJQUFJLEVBQUUsRUFBRSxVQUFVLEVBQUUsSUFBSSxFQUFFLENBQUMsQ0FBQztJQUMvQyxDQUFDO0NBQ0Y7QUFqRUQsc0RBaUVDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0ICogYXMgY2FtZWxjYXNlIGZyb20gJ2NhbWVsY2FzZSc7XG5pbXBvcnQgKiBhcyByZWZsZWN0IGZyb20gJ2pzaWktcmVmbGVjdCc7XG5pbXBvcnQgeyBDb3JlVHlwZXMgfSBmcm9tICcuL2NvcmUtdHlwZXMnO1xuaW1wb3J0IHsgUmVzb3VyY2VSZWZsZWN0aW9uIH0gZnJvbSAnLi9yZXNvdXJjZSc7XG5pbXBvcnQgeyBMaW50ZXIgfSBmcm9tICcuLi9saW50ZXInO1xuXG4vLyB0aGlzIGxpbnRlciB2ZXJpZmllcyB0aGF0IHdlIGhhdmUgTDIgY292ZXJhZ2UuIGl0IGZpbmRzIGFsbCBcIkNmblwiIGNsYXNzZXMgYW5kIHZlcmlmaWVzXG4vLyB0aGF0IHdlIGhhdmUgYSBjb3JyZXNwb25kaW5nIEwxIGNsYXNzIGZvciBpdCB0aGF0J3MgaWRlbnRpZmllZCBhcyBhIHJlc291cmNlLlxuZXhwb3J0IGNvbnN0IGNmblJlc291cmNlTGludGVyID0gbmV3IExpbnRlcihhID0+IENmblJlc291cmNlUmVmbGVjdGlvbi5maW5kQWxsKGEpKTtcblxuY2ZuUmVzb3VyY2VMaW50ZXIuYWRkKHtcbiAgY29kZTogJ3Jlc291cmNlLWNsYXNzJyxcbiAgbWVzc2FnZTogJ2V2ZXJ5IHJlc291cmNlIG11c3QgaGF2ZSBhIHJlc291cmNlIGNsYXNzIChMMiksIGFkZCBcXCdAcmVzb3VyY2UgJXNcXCcgdG8gaXRzIGRvY3N0cmluZycsXG4gIHdhcm5pbmc6IHRydWUsXG4gIGV2YWw6IGUgPT4ge1xuICAgIGNvbnN0IGwyID0gUmVzb3VyY2VSZWZsZWN0aW9uLmZpbmRBbGwoZS5jdHguY2xhc3NUeXBlLmFzc2VtYmx5KS5maW5kKHIgPT4gci5jZm4uZnVsbG5hbWUgPT09IGUuY3R4LmZ1bGxuYW1lKTtcbiAgICBlLmFzc2VydChsMiwgZS5jdHguZnVsbG5hbWUsIGUuY3R4LmZ1bGxuYW1lKTtcbiAgfSxcbn0pO1xuXG5leHBvcnQgY2xhc3MgQ2ZuUmVzb3VyY2VSZWZsZWN0aW9uIHtcbiAgLyoqXG4gICAqIEZpbmRzIGEgQ2ZuIHJlc291cmNlIGNsYXNzIGJ5IGZ1bGwgQ2xvdWRGb3JtYXRpb24gcmVzb3VyY2UgbmFtZSAoZS5nLiBgQVdTOjpTMzo6QnVja2V0YClcbiAgICogQHBhcmFtIGZ1bGxOYW1lIGZpcnN0IHR3byBjb21wb25lbnRzIGFyZSBjYXNlLWluc2Vuc2l0aXZlIChlLmcuIGBhd3M6OnMzOjpCdWNrZXRgIGlzIGVxdWl2YWxlbnQgdG8gYEF3czo6UzM6OkJ1Y2tldGApXG4gICAqL1xuICBwdWJsaWMgc3RhdGljIGZpbmRCeU5hbWUoc3lzOiByZWZsZWN0LlR5cGVTeXN0ZW0sIGZ1bGxOYW1lOiBzdHJpbmcpIHtcbiAgICBmb3IgKGNvbnN0IGNscyBvZiBzeXMuY2xhc3Nlcykge1xuICAgICAgaWYgKGNscy5kb2NzLmN1c3RvbVRhZygnY2xvdWRmb3JtYXRpb25SZXNvdXJjZScpPy50b0xvY2FsZUxvd2VyQ2FzZSgpID09PSBmdWxsTmFtZS50b0xvY2FsZUxvd2VyQ2FzZSgpKSB7XG4gICAgICAgIHJldHVybiBuZXcgQ2ZuUmVzb3VyY2VSZWZsZWN0aW9uKGNscyk7XG4gICAgICB9XG4gICAgfVxuXG4gICAgcmV0dXJuIHVuZGVmaW5lZDtcbiAgfVxuXG4gIC8qKlxuICAgKiBSZXR1cm5zIGFsbCBDRk4gcmVzb3VyY2UgY2xhc3NlcyB3aXRoaW4gYW4gYXNzZW1ibHkuXG4gICAqL1xuICBwdWJsaWMgc3RhdGljIGZpbmRBbGwoYXNzZW1ibHk6IHJlZmxlY3QuQXNzZW1ibHkpIHtcbiAgICByZXR1cm4gYXNzZW1ibHkuY2xhc3Nlc1xuICAgICAgLmZpbHRlcihjID0+IENvcmVUeXBlcy5pc0NmblJlc291cmNlKGMpKVxuICAgICAgLm1hcChjID0+IG5ldyBDZm5SZXNvdXJjZVJlZmxlY3Rpb24oYykpO1xuICB9XG5cbiAgcHVibGljIHJlYWRvbmx5IGNsYXNzVHlwZTogcmVmbGVjdC5DbGFzc1R5cGU7XG4gIHB1YmxpYyByZWFkb25seSBmdWxsbmFtZTogc3RyaW5nOyAvLyBBV1M6OlMzOjpCdWNrZXRcbiAgcHVibGljIHJlYWRvbmx5IG5hbWVzcGFjZTogc3RyaW5nOyAvLyBBV1M6OlMzXG4gIHB1YmxpYyByZWFkb25seSBiYXNlbmFtZTogc3RyaW5nOyAvLyBCdWNrZXRcbiAgcHVibGljIHJlYWRvbmx5IGF0dHJpYnV0ZU5hbWVzOiBzdHJpbmdbXTsgLy8gKG5vcm1hbGl6ZWQpIGJ1Y2tldEFybiwgYnVja2V0TmFtZSwgcXVldWVVcmxcbiAgcHVibGljIHJlYWRvbmx5IGRvYzogc3RyaW5nOyAvLyBsaW5rIHRvIENsb3VkRm9ybWF0aW9uIGRvY3NcblxuICBjb25zdHJ1Y3RvcihjbHM6IHJlZmxlY3QuQ2xhc3NUeXBlKSB7XG4gICAgdGhpcy5jbGFzc1R5cGUgPSBjbHM7XG5cbiAgICB0aGlzLmJhc2VuYW1lID0gY2xzLm5hbWUuc2xpY2UoJ0NmbicubGVuZ3RoKTtcblxuICAgIC8vIEhBQ0s6IGV4dHJhY3QgZnVsbCBDRk4gbmFtZSBmcm9tIGluaXRpYWxpemVyIGRvY3NcbiAgICBjb25zdCBpbml0aWFsaXplckRvYyA9IChjbHMuaW5pdGlhbGl6ZXIgJiYgY2xzLmluaXRpYWxpemVyLmRvY3MuZG9jcy5zdW1tYXJ5KSB8fCAnJztcbiAgICBjb25zdCBvdXQgPSAvYSBuZXcgYChbXmBdKylgLy5leGVjKGluaXRpYWxpemVyRG9jKTtcbiAgICBjb25zdCBmdWxsbmFtZSA9IG91dCAmJiBvdXRbMV07XG4gICAgaWYgKCFmdWxsbmFtZSkge1xuICAgICAgdGhyb3cgbmV3IEVycm9yKGBVbmFibGUgdG8gZXh0cmFjdCBDbG91ZEZvcm1hdGlvbiByZXNvdXJjZSBuYW1lIGZyb20gaW5pdGlhbGl6ZXIgZG9jdW1lbnRhdGlvbiBvZiAke2Nsc31gKTtcbiAgICB9XG5cbiAgICB0aGlzLmZ1bGxuYW1lID0gZnVsbG5hbWU7XG5cbiAgICB0aGlzLm5hbWVzcGFjZSA9IGZ1bGxuYW1lLnNwbGl0KCc6OicpLnNsaWNlKDAsIDIpLmpvaW4oJzo6Jyk7XG5cbiAgICB0aGlzLmF0dHJpYnV0ZU5hbWVzID0gY2xzLm93blByb3BlcnRpZXNcbiAgICAgIC5maWx0ZXIocCA9PiAocC5kb2NzLmRvY3MuY3VzdG9tIHx8IHt9KS5jbG91ZGZvcm1hdGlvbkF0dHJpYnV0ZSlcbiAgICAgIC5tYXAocCA9PiBwLmRvY3MuY3VzdG9tVGFnKCdjbG91ZGZvcm1hdGlvbkF0dHJpYnV0ZScpIHx8ICc8ZXJyb3I+JylcbiAgICAgIC5tYXAocCA9PiB0aGlzLmF0dHJpYnV0ZVByb3BlcnR5TmFtZUZyb21DZm5OYW1lKHApKTtcblxuICAgIHRoaXMuZG9jID0gY2xzLmRvY3MuZG9jcy5zZWUgfHwgJyc7XG4gIH1cblxuICBwcml2YXRlIGF0dHJpYnV0ZVByb3BlcnR5TmFtZUZyb21DZm5OYW1lKG5hbWU6IHN0cmluZyk6IHN0cmluZyB7XG5cbiAgICAvLyBzcGVjaWFsIGNhc2UgKHNvbWVvbmUgd2FzIHNtYXJ0KSwgc3BlY2lhbCBjYXNlIGNvcGllZCBmcm9tIGNmbjJ0c1xuICAgIGlmICh0aGlzLmJhc2VuYW1lID09PSAnU2VjdXJpdHlHcm91cCcgJiYgbmFtZSA9PT0gJ0dyb3VwSWQnKSB7XG4gICAgICByZXR1cm4gJ0lkJztcbiAgICB9XG5cbiAgICByZXR1cm4gY2FtZWxjYXNlKG5hbWUsIHsgcGFzY2FsQ2FzZTogdHJ1ZSB9KTtcbiAgfVxufVxuIl19
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cfn-resource.js","sourceRoot":"","sources":["cfn-resource.ts"],"names":[],"mappings":"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","sourcesContent":["import * as camelcase from 'camelcase';\nimport * as reflect from 'jsii-reflect';\nimport { CoreTypes } from './core-types';\nimport { ResourceReflection } from './resource';\nimport { Linter } from '../linter';\n\nconst cfnResourceTagName = 'cloudformationResource';\n\n// this linter verifies that we have L2 coverage. it finds all \"Cfn\" classes and verifies\n// that we have a corresponding L1 class for it that's identified as a resource.\nexport const cfnResourceLinter = new Linter(a => CfnResourceReflection.findAll(a));\n\n// Cache L1 constructs per type system.\nconst l1ConstructCache = new Map<reflect.TypeSystem, Map<string, reflect.ClassType>>();\n\nfunction cacheL1ConstructsForTypeSystem(sys: reflect.TypeSystem) {\n  if (!l1ConstructCache.has(sys)) {\n    l1ConstructCache.set(sys, new Map<string, reflect.ClassType>());\n\n    for (const cls of sys.classes) {\n      const cfnResourceTag = cls.docs.customTag(cfnResourceTagName);\n\n      if (cfnResourceTag) {\n        l1ConstructCache.get(sys)?.set(cfnResourceTag?.toLocaleLowerCase()!, cls);\n      }\n    }\n  }\n}\n\ncfnResourceLinter.add({\n  code: 'resource-class',\n  message: 'every resource must have a resource class (L2), add \\'@resource %s\\' to its docstring',\n  warning: true,\n  eval: e => {\n    const l2 = ResourceReflection.findAll(e.ctx.classType.assembly).find(r => r.cfn.fullname === e.ctx.fullname);\n    e.assert(l2, e.ctx.fullname, e.ctx.fullname);\n  },\n});\n\nexport class CfnResourceReflection {\n  /**\n   * Finds a Cfn resource class by full CloudFormation resource name (e.g. `AWS::S3::Bucket`)\n   * @param fullName first two components are case-insensitive (e.g. `aws::s3::Bucket` is equivalent to `Aws::S3::Bucket`)\n   */\n  public static findByName(sys: reflect.TypeSystem, fullName: string) {\n    if (!l1ConstructCache.has(sys)) {\n      cacheL1ConstructsForTypeSystem(sys);\n    }\n\n    const cls = l1ConstructCache.get(sys)?.get(fullName.toLowerCase());\n    if (cls) {\n      return new CfnResourceReflection(cls);\n    }\n\n    return undefined;\n  }\n\n  /**\n   * Returns all CFN resource classes within an assembly.\n   */\n  public static findAll(assembly: reflect.Assembly) {\n    return assembly.allClasses\n      .filter(c => CoreTypes.isCfnResource(c))\n      .map(c => new CfnResourceReflection(c));\n  }\n\n  public readonly classType: reflect.ClassType;\n  public readonly fullname: string; // AWS::S3::Bucket\n  public readonly namespace: string; // AWS::S3\n  public readonly basename: string; // Bucket\n  public readonly attributeNames: string[]; // (normalized) bucketArn, bucketName, queueUrl\n  public readonly doc: string; // link to CloudFormation docs\n\n  constructor(cls: reflect.ClassType) {\n    this.classType = cls;\n\n    this.basename = cls.name.slice('Cfn'.length);\n\n    const fullname = cls.docs.customTag('cloudformationResource');\n    if (!fullname) {\n      throw new Error(`Unable to extract CloudFormation resource name from initializer documentation of ${cls}`);\n    }\n\n    this.fullname = fullname;\n\n    this.namespace = fullname.split('::').slice(0, 2).join('::');\n\n    this.attributeNames = cls.ownProperties\n      .filter(p => (p.docs.docs.custom || {}).cloudformationAttribute)\n      .map(p => p.docs.customTag('cloudformationAttribute') || '<error>')\n      .map(p => this.attributePropertyNameFromCfnName(p));\n\n    this.doc = cls.docs.docs.see || '';\n  }\n\n  private attributePropertyNameFromCfnName(name: string): string {\n\n    // special case (someone was smart), special case copied from cfn2ts\n    if (this.basename === 'SecurityGroup' && name === 'GroupId') {\n      return 'Id';\n    }\n\n    return camelcase(name, { pascalCase: true });\n  }\n}\n"]}

package/lib/rules/cfn-resource.ts

@@ -4,10 +4,29 @@ import { CoreTypes } from './core-types';
 import { ResourceReflection } from './resource';
 import { Linter } from '../linter';
 
+const cfnResourceTagName = 'cloudformationResource';
+
 // this linter verifies that we have L2 coverage. it finds all "Cfn" classes and verifies
 // that we have a corresponding L1 class for it that's identified as a resource.
 export const cfnResourceLinter = new Linter(a => CfnResourceReflection.findAll(a));
 
+// Cache L1 constructs per type system.
+const l1ConstructCache = new Map<reflect.TypeSystem, Map<string, reflect.ClassType>>();
+
+function cacheL1ConstructsForTypeSystem(sys: reflect.TypeSystem) {
+  if (!l1ConstructCache.has(sys)) {
+    l1ConstructCache.set(sys, new Map<string, reflect.ClassType>());
+
+    for (const cls of sys.classes) {
+      const cfnResourceTag = cls.docs.customTag(cfnResourceTagName);
+
+      if (cfnResourceTag) {
+        l1ConstructCache.get(sys)?.set(cfnResourceTag?.toLocaleLowerCase()!, cls);
+      }
+    }
+  }
+}
+
 cfnResourceLinter.add({
   code: 'resource-class',
   message: 'every resource must have a resource class (L2), add \'@resource %s\' to its docstring',
@@ -24,10 +43,13 @@ export class CfnResourceReflection {
    * @param fullName first two components are case-insensitive (e.g. `aws::s3::Bucket` is equivalent to `Aws::S3::Bucket`)
    */
   public static findByName(sys: reflect.TypeSystem, fullName: string) {
-    for (const cls of sys.classes) {
-      if (cls.docs.customTag('cloudformationResource')?.toLocaleLowerCase() === fullName.toLocaleLowerCase()) {
-        return new CfnResourceReflection(cls);
-      }
+    if (!l1ConstructCache.has(sys)) {
+      cacheL1ConstructsForTypeSystem(sys);
+    }
+
+    const cls = l1ConstructCache.get(sys)?.get(fullName.toLowerCase());
+    if (cls) {
+      return new CfnResourceReflection(cls);
     }
 
     return undefined;
@@ -37,7 +59,7 @@ export class CfnResourceReflection {
    * Returns all CFN resource classes within an assembly.
    */
   public static findAll(assembly: reflect.Assembly) {
-    return assembly.classes
+    return assembly.allClasses
       .filter(c => CoreTypes.isCfnResource(c))
       .map(c => new CfnResourceReflection(c));
   }
@@ -54,10 +76,7 @@ export class CfnResourceReflection {
 
     this.basename = cls.name.slice('Cfn'.length);
 
-    // HACK: extract full CFN name from initializer docs
-    const initializerDoc = (cls.initializer && cls.initializer.docs.docs.summary) || '';
-    const out = /a new `([^`]+)`/.exec(initializerDoc);
-    const fullname = out && out[1];
+    const fullname = cls.docs.customTag('cloudformationResource');
     if (!fullname) {
       throw new Error(`Unable to extract CloudFormation resource name from initializer documentation of ${cls}`);
     }

package/lib/rules/cloudwatch-events.js

@@ -16,8 +16,8 @@ class EventsReflection extends construct_1.ConstructReflection {
     }
 }
 exports.EventsReflection = EventsReflection;
-const ON_EVENT_OPTIONS_FQN = '@aws-cdk/aws-events.OnEventOptions';
-const EVENT_RULE_FQN = '@aws-cdk/aws-events.Rule';
+const ON_EVENT_OPTIONS_FQN = 'aws-cdk-lib.aws_events.OnEventOptions';
+const EVENT_RULE_FQN = 'aws-cdk-lib.aws_events.Rule';
 exports.eventsLinter.add({
     code: 'events-in-interface',
     message: '\'onXxx()\' methods should also be defined on construct interface',
@@ -66,4 +66,4 @@ function isDirectEventMethod(m) {
 function isCloudTrailEventMethod(m) {
     return m.name.startsWith('onCloudTrail');
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xvdWR3YXRjaC1ldmVudHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJjbG91ZHdhdGNoLWV2ZW50cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFDQSwyQ0FBa0Q7QUFDbEQsNkNBQXlDO0FBQ3pDLHNDQUFtQztBQUV0QixRQUFBLFlBQVksR0FBRyxJQUFJLGVBQU0sQ0FBbUIsUUFBUSxDQUFDLEVBQUUsQ0FBQyxRQUFRLENBQUMsT0FBTztLQUNsRixNQUFNLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxzQkFBUyxDQUFDLGdCQUFnQixDQUFDLENBQUMsQ0FBQyxDQUFDO0tBQzFDLEdBQUcsQ0FBQyxTQUFTLENBQUMsRUFBRSxDQUFDLElBQUksZ0JBQWdCLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQyxDQUFDO0FBRXRELE1BQWEsZ0JBQWlCLFNBQVEsK0JBQW1CO0lBQ3ZELElBQVcsa0JBQWtCO1FBQzNCLE9BQU8sSUFBSSxDQUFDLFNBQVMsQ0FBQyxVQUFVLENBQUMsTUFBTSxDQUFDLG1CQUFtQixDQUFDLENBQUM7SUFDL0QsQ0FBQztJQUVELElBQVcsc0JBQXNCO1FBQy9CLE9BQU8sSUFBSSxDQUFDLFNBQVMsQ0FBQyxVQUFVLENBQUMsTUFBTSxDQUFDLHVCQUF1QixDQUFDLENBQUM7SUFDbkUsQ0FBQztDQUNGO0FBUkQsNENBUUM7QUFFRCxNQUFNLG9CQUFvQixHQUFHLHVDQUF1QyxDQUFDO0FBQ3JFLE1BQU0sY0FBYyxHQUFHLDZCQUE2QixDQUFDO0FBRXJELG9CQUFZLENBQUMsR0FBRyxDQUFDO0lBQ2YsSUFBSSxFQUFFLHFCQUFxQjtJQUMzQixPQUFPLEVBQUUsbUVBQW1FO0lBQzVFLElBQUksRUFBRSxDQUFDLENBQUMsRUFBRTtRQUNSLEtBQUssTUFBTSxNQUFNLElBQUksQ0FBQyxDQUFDLEdBQUcsQ0FBQyxrQkFBa0IsQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxzQkFBc0IsQ0FBQyxFQUFFO1lBQ2xGLENBQUMsQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLENBQUMsR0FBRyxDQUFDLGFBQWEsSUFBSSxDQUFDLENBQUMsR0FBRyxDQUFDLGFBQWEsQ0FBQyxVQUFVLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLENBQUMsU0FBUyxDQUFDLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLElBQUksS0FBSyxNQUFNLENBQUMsSUFBSSxDQUFDLEVBQUUsR0FBRyxDQUFDLENBQUMsR0FBRyxDQUFDLEdBQUcsSUFBSSxNQUFNLENBQUMsSUFBSSxFQUFFLENBQUMsQ0FBQztTQUM3SjtJQUNILENBQUM7Q0FDRixDQUFDLENBQUM7QUFFSCxvQkFBWSxDQUFDLEdBQUcsQ0FBQztJQUNmLElBQUksRUFBRSxnQkFBZ0I7SUFDdEIsT0FBTyxFQUFFLGdHQUFnRztJQUN6RyxJQUFJLEVBQUUsQ0FBQyxDQUFDLEVBQUU7UUFDUixDQUFDLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxHQUFHLENBQUMsa0JBQWtCLENBQUMsTUFBTSxLQUFLLENBQUMsSUFBSSxDQUFDLENBQUMsR0FBRyxDQUFDLFNBQVMsQ0FBQyxVQUFVLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLElBQUksS0FBSyxTQUFTLENBQUMsRUFBRSxDQUFDLENBQUMsR0FBRyxDQUFDLEdBQUcsQ0FBQyxDQUFDO0lBQzNILENBQUM7Q0FDRixDQUFDLENBQUM7QUFFSCxvQkFBWSxDQUFDLEdBQUcsQ0FBQztJQUNmLElBQUksRUFBRSwyQkFBMkI7SUFDakMsT0FBTyxFQUFFLG9IQUFvSDtJQUM3SCxJQUFJLEVBQUUsQ0FBQyxDQUFDLEVBQUU7UUFDUixDQUFDLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxHQUFHLENBQUMsc0JBQXNCLENBQUMsTUFBTSxLQUFLLENBQUMsSUFBSSxDQUFDLENBQUMsR0FBRyxDQUFDLFNBQVMsQ0FBQyxVQUFVLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLElBQUksS0FBSyxtQkFBbUIsQ0FBQyxFQUFFLENBQUMsQ0FBQyxHQUFHLENBQUMsR0FBRyxDQUFDLENBQUM7SUFDekksQ0FBQztDQUNGLENBQUMsQ0FBQztBQUVILG9CQUFZLENBQUMsR0FBRyxDQUFDO0lBQ2YsSUFBSSxFQUFFLHlCQUF5QjtJQUMvQixPQUFPLEVBQUUsc0lBQXNJO0lBQy9JLElBQUksRUFBRSxDQUFDLENBQUMsRUFBRTtRQUNSLEtBQUssTUFBTSxNQUFNLElBQUksQ0FBQyxDQUFDLEdBQUcsQ0FBQyxrQkFBa0IsRUFBRTtZQUM3Qyx3RUFBd0U7WUFDeEUsSUFBSSxNQUFNLENBQUMsU0FBUyxFQUFFO2dCQUNwQixTQUFTO2FBQ1Y7WUFDRCxDQUFDLENBQUMsZUFBZSxDQUFDLE1BQU0sRUFBRTtnQkFDeEIsVUFBVSxFQUFFO29CQUNWLEVBQUUsSUFBSSxFQUFFLFFBQVEsRUFBRTtvQkFDbEIsRUFBRSxJQUFJLEVBQUUsb0JBQW9CLEVBQUUsY0FBYyxFQUFFLElBQUksRUFBRSxRQUFRLEVBQUUsSUFBSSxFQUFFO2lCQUNyRTtnQkFDRCxPQUFPLEVBQUUsY0FBYzthQUN4QixDQUFDLENBQUM7U0FDSjtJQUNILENBQUM7Q0FDRixDQUFDLENBQUM7QUFFSCxTQUFTLG1CQUFtQixDQUFDLENBQWlCO0lBQzVDLE9BQU8sQ0FBQyxDQUFDLENBQUMsU0FBUyxJQUFJLENBQUMsQ0FBQyxJQUFJLENBQUMsVUFBVSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUUsQ0FBQyxDQUFDLElBQUksQ0FBQyxVQUFVLENBQUMsY0FBYyxDQUFDLENBQUM7QUFDeEYsQ0FBQztBQUVELFNBQVMsdUJBQXVCLENBQUMsQ0FBaUI7SUFDaEQsT0FBTyxDQUFDLENBQUMsSUFBSSxDQUFDLFVBQVUsQ0FBQyxjQUFjLENBQUMsQ0FBQztBQUMzQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0ICogYXMgcmVmbGVjdCBmcm9tICdqc2lpLXJlZmxlY3QnO1xuaW1wb3J0IHsgQ29uc3RydWN0UmVmbGVjdGlvbiB9IGZyb20gJy4vY29uc3RydWN0JztcbmltcG9ydCB7IENvcmVUeXBlcyB9IGZyb20gJy4vY29yZS10eXBlcyc7XG5pbXBvcnQgeyBMaW50ZXIgfSBmcm9tICcuLi9saW50ZXInO1xuXG5leHBvcnQgY29uc3QgZXZlbnRzTGludGVyID0gbmV3IExpbnRlcjxFdmVudHNSZWZsZWN0aW9uPihhc3NlbWJseSA9PiBhc3NlbWJseS5jbGFzc2VzXG4gIC5maWx0ZXIodCA9PiBDb3JlVHlwZXMuaXNDb25zdHJ1Y3RDbGFzcyh0KSlcbiAgLm1hcChjb25zdHJ1Y3QgPT4gbmV3IEV2ZW50c1JlZmxlY3Rpb24oY29uc3RydWN0KSkpO1xuXG5leHBvcnQgY2xhc3MgRXZlbnRzUmVmbGVjdGlvbiBleHRlbmRzIENvbnN0cnVjdFJlZmxlY3Rpb24ge1xuICBwdWJsaWMgZ2V0IGRpcmVjdEV2ZW50TWV0aG9kcygpIHtcbiAgICByZXR1cm4gdGhpcy5jbGFzc1R5cGUuYWxsTWV0aG9kcy5maWx0ZXIoaXNEaXJlY3RFdmVudE1ldGhvZCk7XG4gIH1cblxuICBwdWJsaWMgZ2V0IGNsb3VkVHJhaWxFdmVudE1ldGhvZHMoKSB7XG4gICAgcmV0dXJuIHRoaXMuY2xhc3NUeXBlLmFsbE1ldGhvZHMuZmlsdGVyKGlzQ2xvdWRUcmFpbEV2ZW50TWV0aG9kKTtcbiAgfVxufVxuXG5jb25zdCBPTl9FVkVOVF9PUFRJT05TX0ZRTiA9ICdhd3MtY2RrLWxpYi5hd3NfZXZlbnRzLk9uRXZlbnRPcHRpb25zJztcbmNvbnN0IEVWRU5UX1JVTEVfRlFOID0gJ2F3cy1jZGstbGliLmF3c19ldmVudHMuUnVsZSc7XG5cbmV2ZW50c0xpbnRlci5hZGQoe1xuICBjb2RlOiAnZXZlbnRzLWluLWludGVyZmFjZScsXG4gIG1lc3NhZ2U6ICdcXCdvblh4eCgpXFwnIG1ldGhvZHMgc2hvdWxkIGFsc28gYmUgZGVmaW5lZCBvbiBjb25zdHJ1Y3QgaW50ZXJmYWNlJyxcbiAgZXZhbDogZSA9PiB7XG4gICAgZm9yIChjb25zdCBtZXRob2Qgb2YgZS5jdHguZGlyZWN0RXZlbnRNZXRob2RzLmNvbmNhdChlLmN0eC5jbG91ZFRyYWlsRXZlbnRNZXRob2RzKSkge1xuICAgICAgZS5hc3NlcnQoIWUuY3R4LmludGVyZmFjZVR5cGUgfHwgZS5jdHguaW50ZXJmYWNlVHlwZS5hbGxNZXRob2RzLmZpbHRlcihtID0+ICFtLnByb3RlY3RlZCkuc29tZShtID0+IG0ubmFtZSA9PT0gbWV0aG9kLm5hbWUpLCBgJHtlLmN0eC5mcW59LiR7bWV0aG9kLm5hbWV9YCk7XG4gICAgfVxuICB9LFxufSk7XG5cbmV2ZW50c0xpbnRlci5hZGQoe1xuICBjb2RlOiAnZXZlbnRzLWdlbmVyaWMnLFxuICBtZXNzYWdlOiAnaWYgdGhlcmUgYXJlIHNwZWNpZmljIFxcJ29uWHh4KClcXCcgbWV0aG9kcywgdGhlcmUgc2hvdWxkIGFsc28gYmUgYSBnZW5lcmljIFxcJ29uRXZlbnQoKVxcJyBtZXRob2QnLFxuICBldmFsOiBlID0+IHtcbiAgICBlLmFzc2VydChlLmN0eC5kaXJlY3RFdmVudE1ldGhvZHMubGVuZ3RoID09PSAwIHx8IGUuY3R4LmNsYXNzVHlwZS5hbGxNZXRob2RzLnNvbWUobSA9PiBtLm5hbWUgPT09ICdvbkV2ZW50JyksIGUuY3R4LmZxbik7XG4gIH0sXG59KTtcblxuZXZlbnRzTGludGVyLmFkZCh7XG4gIGNvZGU6ICdldmVudHMtZ2VuZXJpYy1jbG91ZHRyYWlsJyxcbiAgbWVzc2FnZTogJ2lmIHRoZXJlIGFyZSBzcGVjaWZpYyBcXCdvbkNsb3VkVHJhaWxYeHgoKVxcJyBtZXRob2RzLCB0aGVyZSBzaG91bGQgYWxzbyBiZSBhIGdlbmVyaWMgXFwnb25DbG91ZFRyYWlsRXZlbnQoKVxcJyBtZXRob2QnLFxuICBldmFsOiBlID0+IHtcbiAgICBlLmFzc2VydChlLmN0eC5jbG91ZFRyYWlsRXZlbnRNZXRob2RzLmxlbmd0aCA9PT0gMCB8fCBlLmN0eC5jbGFzc1R5cGUuYWxsTWV0aG9kcy5zb21lKG0gPT4gbS5uYW1lID09PSAnb25DbG91ZFRyYWlsRXZlbnQnKSwgZS5jdHguZnFuKTtcbiAgfSxcbn0pO1xuXG5ldmVudHNMaW50ZXIuYWRkKHtcbiAgY29kZTogJ2V2ZW50cy1tZXRob2Qtc2lnbmF0dXJlJyxcbiAgbWVzc2FnZTogJ2FsbCBcXCdvblh4eCgpXFwnIG1ldGhvZHMgc2hvdWxkIGhhdmUgdGhlIENsb3VkV2F0Y2ggRXZlbnRzIHNpZ25hdHVyZSAoaWQ6IHN0cmluZywgb3B0aW9uczogZXZlbnRzLk9uRXZlbnRPcHRpb25zID0ge30pID0+IGV2ZW50cy5SdWxlJyxcbiAgZXZhbDogZSA9PiB7XG4gICAgZm9yIChjb25zdCBtZXRob2Qgb2YgZS5jdHguZGlyZWN0RXZlbnRNZXRob2RzKSB7XG4gICAgICAvLyBnaXZlIHNsYWNrIHRvIHByb3RlY3RlZCBtZXRob2RzIGxpa2UgXCJvblN5bnRoZXNpemVcIiwgXCJvblByZXBhcmVcIiwgLi4uXG4gICAgICBpZiAobWV0aG9kLnByb3RlY3RlZCkge1xuICAgICAgICBjb250aW51ZTtcbiAgICAgIH1cbiAgICAgIGUuYXNzZXJ0U2lnbmF0dXJlKG1ldGhvZCwge1xuICAgICAgICBwYXJhbWV0ZXJzOiBbXG4gICAgICAgICAgeyB0eXBlOiAnc3RyaW5nJyB9LFxuICAgICAgICAgIHsgdHlwZTogT05fRVZFTlRfT1BUSU9OU19GUU4sIHN1YnR5cGVBbGxvd2VkOiB0cnVlLCBvcHRpb25hbDogdHJ1ZSB9LFxuICAgICAgICBdLFxuICAgICAgICByZXR1cm5zOiBFVkVOVF9SVUxFX0ZRTixcbiAgICAgIH0pO1xuICAgIH1cbiAgfSxcbn0pO1xuXG5mdW5jdGlvbiBpc0RpcmVjdEV2ZW50TWV0aG9kKG06IHJlZmxlY3QuTWV0aG9kKSB7XG4gIHJldHVybiAhbS5wcm90ZWN0ZWQgJiYgbS5uYW1lLnN0YXJ0c1dpdGgoJ29uJykgJiYgISBtLm5hbWUuc3RhcnRzV2l0aCgnb25DbG91ZFRyYWlsJyk7XG59XG5cbmZ1bmN0aW9uIGlzQ2xvdWRUcmFpbEV2ZW50TWV0aG9kKG06IHJlZmxlY3QuTWV0aG9kKSB7XG4gIHJldHVybiBtLm5hbWUuc3RhcnRzV2l0aCgnb25DbG91ZFRyYWlsJyk7XG59XG4iXX0=

package/lib/rules/cloudwatch-events.ts

@@ -17,8 +17,8 @@ export class EventsReflection extends ConstructReflection {
   }
 }
 
-const ON_EVENT_OPTIONS_FQN = '@aws-cdk/aws-events.OnEventOptions';
-const EVENT_RULE_FQN = '@aws-cdk/aws-events.Rule';
+const ON_EVENT_OPTIONS_FQN = 'aws-cdk-lib.aws_events.OnEventOptions';
+const EVENT_RULE_FQN = 'aws-cdk-lib.aws_events.Rule';
 
 eventsLinter.add({
   code: 'events-in-interface',

package/lib/rules/construct.d.ts

@@ -20,6 +20,7 @@ export declare class ConstructReflection {
     readonly sys: reflect.TypeSystem;
     readonly core: CoreTypes;
     constructor(classType: reflect.ClassType);
+    private typePrefix;
     private tryFindInterface;
     private tryFindProps;
 }