awslint 2.234.0-alpha.0 → 2.235.0-alpha.0

package/lib/rules/api.js

@@ -4,122 +4,151 @@ exports.apiLinter = void 0;
 const construct_1 = require("./construct");
 const core_types_1 = require("./core-types");
 const linter_1 = require("../linter");
-const EXCLUDE_ANNOTATION_REF_VIA_INTERFACE = '[disable-awslint:ref-via-interface]';
+const CLASS_ON_PURPOSE_RULE = 'ref-via-interface';
+const L2_INTERFACE_ON_PURPOSE_RULE = 'prefer-ref-interface';
 // lint all constructs that are not L1 resources
 exports.apiLinter = new linter_1.Linter(a => construct_1.ConstructReflection
     .findAllConstructs(a)
     .filter(c => !core_types_1.CoreTypes.isCfnResource(c.classType)));
 exports.apiLinter.add({
-    code: 'ref-via-interface',
-    message: 'API should use interface and not the concrete class (%s). ' +
-        `If this is intentional, add "${EXCLUDE_ANNOTATION_REF_VIA_INTERFACE}" to element's jsdoc`,
+    code: CLASS_ON_PURPOSE_RULE,
+    message: 'API should use interface (preferably IxxxRef, otherwise Ixxx) and not the concrete class (%s). ' +
+        `If this is intentional, add "${ignoreTag(CLASS_ON_PURPOSE_RULE)}" to element's jsdoc`,
     eval: e => {
-        const cls = e.ctx.classType;
-        const visited = new Set();
-        assertClass(cls);
-        function assertClass(type) {
-            if (visited.has(type.fqn)) {
-                return;
-            }
-            visited.add(type.fqn);
-            for (const method of type.allMethods) {
-                assertMethod(method);
-            }
-            if (type.initializer) {
-                assertMethod(type.initializer);
-            }
-        }
-        function assertDataType(type) {
-            for (const property of type.allProperties) {
-                assertProperty(property);
-            }
-        }
-        function assertInterface(type) {
-            if (visited.has(type.fqn)) {
-                return;
-            }
-            visited.add(type.fqn);
-            if (type.datatype) {
-                assertDataType(type);
-            }
-            for (const method of type.allMethods) {
-                assertMethod(method);
-            }
-        }
-        function assertProperty(property) {
-            if (property.protected) {
-                return;
-            }
-            const site = property.overrides ? property.overrides : property.parentType;
-            assertType(property.type, property.docs, `${site.fqn}.${property.name}`);
-        }
-        function assertMethod(method) {
-            if (method.protected) {
-                return;
-            }
-            const site = method.overrides ? method.overrides : method.parentType;
-            const scope = `${site.fqn}.${method.name}`;
-            let firstMethod = site.isClassType() || site.isInterfaceType()
-                ? site.allMethods.find(m => m.name === method.name)
-                : undefined;
-            if (!firstMethod) {
-                firstMethod = method;
-            }
-            for (const param of firstMethod.parameters) {
-                assertType(param.type, param.docs, `${scope}.${param.name}`);
-            }
-            // note that we do not require that return values will use an interface
-        }
-        function assertType(type, docs, scope) {
-            if (type.primitive) {
-                return;
-            }
-            if (type.void) {
-                return;
-            }
-            if (type.arrayOfType) {
-                return assertType(type.arrayOfType, docs, scope);
-            }
-            if (type.mapOfType) {
-                return assertType(type.mapOfType, docs, scope);
-            }
-            if (type.unionOfTypes) {
-                for (const t of type.unionOfTypes) {
-                    assertType(t, docs, scope);
-                }
-                return;
-            }
-            if (type.intersectionOfTypes) {
-                for (const t of type.intersectionOfTypes) {
-                    assertType(t, docs, scope);
-                }
-                return;
-            }
-            // interfaces are okay
-            if (type.type && type.type.isInterfaceType()) {
-                return assertInterface(type.type);
-            }
-            // enums are okay
-            if (type.type && type.type.isEnumType()) {
-                return;
-            }
-            // classes are okay as long as they are not resource constructs
-            if (type.type && type.type.isClassType()) {
-                if (!core_types_1.CoreTypes.isResourceClass(type.type)) {
-                    return;
-                }
-                if (type.type.fqn === e.ctx.core.baseConstructClassFqn) {
+        visitParameters(e.ctx.classType, {
+            visitType: function (type, docs, scope) {
+                // allow exclusion of this rule
+                if (docHasIgnoreTag(docs, CLASS_ON_PURPOSE_RULE)) {
                     return;
                 }
+                // Assert that all types that reference classes are not resource constructs. Those
+                // should be referenced via Interface.
+                e.assert(!type.type
+                    || !type.type.isClassType()
+                    || !core_types_1.CoreTypes.isResourceClass(type.type)
+                    // Make an exception for `constructs.Construct`.
+                    || type.type.fqn === e.ctx.core.baseConstructClassFqn, scope, type.type?.fqn);
+            },
+        });
+    },
+});
+exports.apiLinter.add({
+    code: L2_INTERFACE_ON_PURPOSE_RULE,
+    message: 'API should prefer to use the L1 reference interface (IxxxRef) and not the L2 interface (%s). ' +
+        `If this is intentional, add "${ignoreTag(L2_INTERFACE_ON_PURPOSE_RULE)}" to element's jsdoc`,
+    eval: e => {
+        visitParameters(e.ctx.classType, {
+            visitType: function (type, docs, scope) {
                 // allow exclusion of this rule
-                if (docs.summary.includes(EXCLUDE_ANNOTATION_REF_VIA_INTERFACE) || docs.remarks.includes(EXCLUDE_ANNOTATION_REF_VIA_INTERFACE)) {
+                if (docHasIgnoreTag(docs, L2_INTERFACE_ON_PURPOSE_RULE)) {
                     return;
                 }
-                e.assert(false, scope, type.type.fqn);
-                return;
-            }
-            throw new Error(`invalid type reference: ${type.toString()}`);
-        }
+                // Assert that all types that interfaces are not L2 interfaces. This is actually not checking
+                // that they ARE Ref interfaces, just that they aren't L2 interfaces (could also be service-
+                // specific non-resource interfaces, and those are fine too)
+                e.assert(!type.type
+                    || !type.type.isInterfaceType()
+                    || type.type.datatype
+                    || !core_types_1.CoreTypes.isL2Interface(type.type), scope, type.type?.fqn);
+            },
+        });
     },
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api.js","sourceRoot":"","sources":["api.ts"],"names":[],"mappings":"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","sourcesContent":["import * as reflect from 'jsii-reflect';\nimport { ConstructReflection } from './construct';\nimport { CoreTypes } from './core-types';\nimport { Linter } from '../linter';\n\nconst EXCLUDE_ANNOTATION_REF_VIA_INTERFACE = '[disable-awslint:ref-via-interface]';\n\n// lint all constructs that are not L1 resources\nexport const apiLinter = new Linter(a => ConstructReflection\n  .findAllConstructs(a)\n  .filter(c => !CoreTypes.isCfnResource(c.classType)));\n\napiLinter.add({\n  code: 'ref-via-interface',\n  message: 'API should use interface and not the concrete class (%s). ' +\n    `If this is intentional, add \"${EXCLUDE_ANNOTATION_REF_VIA_INTERFACE}\" to element's jsdoc`,\n  eval: e => {\n    const cls = e.ctx.classType;\n    const visited = new Set<string>();\n\n    assertClass(cls);\n\n    function assertClass(type: reflect.ClassType): void {\n      if (visited.has(type.fqn)) { return; }\n      visited.add(type.fqn);\n\n      for (const method of type.allMethods) {\n        assertMethod(method);\n      }\n\n      if (type.initializer) {\n        assertMethod(type.initializer);\n      }\n    }\n\n    function assertDataType(type: reflect.InterfaceType): void {\n      for (const property of type.allProperties) {\n        assertProperty(property);\n      }\n    }\n\n    function assertInterface(type: reflect.InterfaceType): void {\n      if (visited.has(type.fqn)) { return; }\n      visited.add(type.fqn);\n\n      if (type.datatype) {\n        assertDataType(type);\n      }\n\n      for (const method of type.allMethods) {\n        assertMethod(method);\n      }\n    }\n\n    function assertProperty(property: reflect.Property) {\n      if (property.protected) {\n        return;\n      }\n\n      const site = property.overrides ? property.overrides : property.parentType;\n      assertType(property.type, property.docs, `${site.fqn}.${property.name}`);\n    }\n\n    function assertMethod(method: reflect.Callable) {\n      if (method.protected) {\n        return;\n      }\n\n      const site = method.overrides ? method.overrides : method.parentType;\n      const scope = `${site.fqn}.${method.name}`;\n\n      let firstMethod: reflect.Callable | undefined = site.isClassType() || site.isInterfaceType()\n        ? site.allMethods.find(m => m.name === method.name)\n        : undefined;\n\n      if (!firstMethod) {\n        firstMethod = method;\n      }\n\n      for (const param of firstMethod.parameters) {\n        assertType(param.type, param.docs, `${scope}.${param.name}`);\n      }\n\n      // note that we do not require that return values will use an interface\n    }\n\n    function assertType(type: reflect.TypeReference, docs: reflect.Docs, scope: string): void {\n      if (type.primitive) {\n        return;\n      }\n\n      if (type.void) {\n        return;\n      }\n\n      if (type.arrayOfType) {\n        return assertType(type.arrayOfType, docs, scope);\n      }\n\n      if (type.mapOfType) {\n        return assertType(type.mapOfType, docs, scope);\n      }\n\n      if (type.unionOfTypes) {\n        for (const t of type.unionOfTypes) {\n          assertType(t, docs, scope);\n        }\n        return;\n      }\n\n      if (type.intersectionOfTypes) {\n        for (const t of type.intersectionOfTypes) {\n          assertType(t, docs, scope);\n        }\n        return;\n      }\n\n      // interfaces are okay\n      if (type.type && type.type.isInterfaceType()) {\n        return assertInterface(type.type);\n      }\n\n      // enums are okay\n      if (type.type && type.type.isEnumType()) {\n        return;\n      }\n\n      // classes are okay as long as they are not resource constructs\n      if (type.type && type.type.isClassType()) {\n        if (!CoreTypes.isResourceClass(type.type)) {\n          return;\n        }\n\n        if (type.type.fqn === e.ctx.core.baseConstructClassFqn) {\n          return;\n        }\n\n        // allow exclusion of this rule\n        if (docs.summary.includes(EXCLUDE_ANNOTATION_REF_VIA_INTERFACE) || docs.remarks.includes(EXCLUDE_ANNOTATION_REF_VIA_INTERFACE)) {\n          return;\n        }\n\n        e.assert(false, scope, type.type.fqn);\n        return;\n      }\n\n      throw new Error(`invalid type reference: ${type.toString()}`);\n    }\n  },\n});\n"]}
+function ignoreTag(rule) {
+    return `[disable-awslint:${rule}]`;
+}
+function docHasIgnoreTag(docs, rule) {
+    const tag = ignoreTag(rule);
+    return docs.summary.includes(tag) || docs.remarks.includes(tag);
+}
+/**
+ * Visit all types in the API of a given type
+ *
+ * This visits method parameters and members of structs of method parameters.
+ */
+function visitParameters(root, visitor) {
+    const visited = new Set();
+    if (root.isClassType()) {
+        assertClass(root);
+    }
+    else if (root.isInterfaceType()) {
+        assertInterface(root);
+    }
+    else {
+        throw new Error(`invalid type: ${root.toString()}`);
+    }
+    function assertClass(type) {
+        if (visited.has(type.fqn)) {
+            return;
+        }
+        visited.add(type.fqn);
+        for (const method of type.allMethods) {
+            assertMethod(method);
+        }
+        if (type.initializer) {
+            assertMethod(type.initializer);
+        }
+    }
+    function assertDataType(type) {
+        for (const property of type.allProperties) {
+            assertProperty(property);
+        }
+    }
+    function assertInterface(type) {
+        if (visited.has(type.fqn)) {
+            return;
+        }
+        visited.add(type.fqn);
+        if (type.datatype) {
+            assertDataType(type);
+        }
+        for (const method of type.allMethods) {
+            assertMethod(method);
+        }
+    }
+    function assertProperty(property) {
+        if (property.protected) {
+            return;
+        }
+        const site = property.overrides ? property.overrides : property.parentType;
+        assertType(property.type, property.docs, `${site.fqn}.${property.name}`);
+    }
+    function assertMethod(method) {
+        if (method.protected) {
+            return;
+        }
+        const site = method.overrides ? method.overrides : method.parentType;
+        const scope = `${site.fqn}.${method.name}`;
+        let firstMethod = site.isClassType() || site.isInterfaceType()
+            ? site.allMethods.find(m => m.name === method.name)
+            : undefined;
+        if (!firstMethod) {
+            firstMethod = method;
+        }
+        for (const param of firstMethod.parameters) {
+            assertType(param.type, param.docs, `${scope}.${param.name}`);
+        }
+        // note that we do not require that return values will use an interface
+    }
+    function assertType(type, docs, scope) {
+        visitor.visitType(type, docs, scope);
+        // And recurse
+        if (type.arrayOfType) {
+            return assertType(type.arrayOfType, docs, scope);
+        }
+        if (type.mapOfType) {
+            return assertType(type.mapOfType, docs, scope);
+        }
+        if (type.unionOfTypes) {
+            for (const t of type.unionOfTypes) {
+                assertType(t, docs, scope);
+            }
+            return;
+        }
+        // interfaces are okay
+        if (type.type && type.type.isInterfaceType()) {
+            return assertInterface(type.type);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api.js","sourceRoot":"","sources":["api.ts"],"names":[],"mappings":"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","sourcesContent":["import * as reflect from 'jsii-reflect';\nimport { ConstructReflection } from './construct';\nimport { CoreTypes } from './core-types';\nimport { Linter } from '../linter';\n\nconst CLASS_ON_PURPOSE_RULE = 'ref-via-interface';\nconst L2_INTERFACE_ON_PURPOSE_RULE = 'prefer-ref-interface';\n\n// lint all constructs that are not L1 resources\nexport const apiLinter = new Linter(a => ConstructReflection\n  .findAllConstructs(a)\n  .filter(c => !CoreTypes.isCfnResource(c.classType)));\n\napiLinter.add({\n  code: CLASS_ON_PURPOSE_RULE,\n  message: 'API should use interface (preferably IxxxRef, otherwise Ixxx) and not the concrete class (%s). ' +\n    `If this is intentional, add \"${ignoreTag(CLASS_ON_PURPOSE_RULE)}\" to element's jsdoc`,\n  eval: e => {\n    visitParameters(e.ctx.classType, {\n      visitType: function (type: reflect.TypeReference, docs: reflect.Docs, scope: string): void {\n        // allow exclusion of this rule\n        if (docHasIgnoreTag(docs, CLASS_ON_PURPOSE_RULE)) {\n          return;\n        }\n\n        // Assert that all types that reference classes are not resource constructs. Those\n        // should be referenced via Interface.\n        e.assert(!type.type\n          || !type.type.isClassType()\n          || !CoreTypes.isResourceClass(type.type)\n          // Make an exception for `constructs.Construct`.\n          || type.type.fqn === e.ctx.core.baseConstructClassFqn,\n        scope,\n        type.type?.fqn,\n        );\n      },\n    });\n  },\n});\n\napiLinter.add({\n  code: L2_INTERFACE_ON_PURPOSE_RULE,\n  message: 'API should prefer to use the L1 reference interface (IxxxRef) and not the L2 interface (%s). ' +\n    `If this is intentional, add \"${ignoreTag(L2_INTERFACE_ON_PURPOSE_RULE)}\" to element's jsdoc`,\n  eval: e => {\n    visitParameters(e.ctx.classType, {\n      visitType: function (type: reflect.TypeReference, docs: reflect.Docs, scope: string): void {\n        // allow exclusion of this rule\n        if (docHasIgnoreTag(docs, L2_INTERFACE_ON_PURPOSE_RULE)) {\n          return;\n        }\n\n        // Assert that all types that interfaces are not L2 interfaces. This is actually not checking\n        // that they ARE Ref interfaces, just that they aren't L2 interfaces (could also be service-\n        // specific non-resource interfaces, and those are fine too)\n        e.assert(!type.type\n          || !type.type.isInterfaceType()\n          || type.type.datatype\n          || !CoreTypes.isL2Interface(type.type),\n        scope,\n        type.type?.fqn,\n        );\n      },\n    });\n  },\n});\n\nfunction ignoreTag(rule: string) {\n  return `[disable-awslint:${rule}]`;\n}\n\nfunction docHasIgnoreTag(docs: reflect.Docs, rule: string) {\n  const tag = ignoreTag(rule);\n  return docs.summary.includes(tag) || docs.remarks.includes(tag);\n}\n\n/**\n * Visit all types in the API of a given type\n *\n * This visits method parameters and members of structs of method parameters.\n */\nfunction visitParameters(root: reflect.Type, visitor: TypeVisitor) {\n  const visited = new Set<string>();\n\n  if (root.isClassType()) {\n    assertClass(root);\n  } else if (root.isInterfaceType()) {\n    assertInterface(root);\n  } else {\n    throw new Error(`invalid type: ${root.toString()}`);\n  }\n\n  function assertClass(type: reflect.ClassType): void {\n    if (visited.has(type.fqn)) { return; }\n    visited.add(type.fqn);\n\n    for (const method of type.allMethods) {\n      assertMethod(method);\n    }\n\n    if (type.initializer) {\n      assertMethod(type.initializer);\n    }\n  }\n\n  function assertDataType(type: reflect.InterfaceType): void {\n    for (const property of type.allProperties) {\n      assertProperty(property);\n    }\n  }\n\n  function assertInterface(type: reflect.InterfaceType): void {\n    if (visited.has(type.fqn)) { return; }\n    visited.add(type.fqn);\n\n    if (type.datatype) {\n      assertDataType(type);\n    }\n\n    for (const method of type.allMethods) {\n      assertMethod(method);\n    }\n  }\n\n  function assertProperty(property: reflect.Property) {\n    if (property.protected) {\n      return;\n    }\n\n    const site = property.overrides ? property.overrides : property.parentType;\n    assertType(property.type, property.docs, `${site.fqn}.${property.name}`);\n  }\n\n  function assertMethod(method: reflect.Callable) {\n    if (method.protected) {\n      return;\n    }\n\n    const site = method.overrides ? method.overrides : method.parentType;\n    const scope = `${site.fqn}.${method.name}`;\n\n    let firstMethod: reflect.Callable | undefined = site.isClassType() || site.isInterfaceType()\n      ? site.allMethods.find(m => m.name === method.name)\n      : undefined;\n\n    if (!firstMethod) {\n      firstMethod = method;\n    }\n\n    for (const param of firstMethod.parameters) {\n      assertType(param.type, param.docs, `${scope}.${param.name}`);\n    }\n\n    // note that we do not require that return values will use an interface\n  }\n\n  function assertType(type: reflect.TypeReference, docs: reflect.Docs, scope: string): void {\n    visitor.visitType(type, docs, scope);\n\n    // And recurse\n    if (type.arrayOfType) {\n      return assertType(type.arrayOfType, docs, scope);\n    }\n\n    if (type.mapOfType) {\n      return assertType(type.mapOfType, docs, scope);\n    }\n\n    if (type.unionOfTypes) {\n      for (const t of type.unionOfTypes) {\n        assertType(t, docs, scope);\n      }\n      return;\n    }\n\n    // interfaces are okay\n    if (type.type && type.type.isInterfaceType()) {\n      return assertInterface(type.type);\n    }\n  }\n}\n\ninterface TypeVisitor {\n  visitType(type: reflect.TypeReference, docs: reflect.Docs, scope: string): void;\n}\n"]}

package/lib/rules/api.ts

@@ -3,7 +3,8 @@ import { ConstructReflection } from './construct';
 import { CoreTypes } from './core-types';
 import { Linter } from '../linter';
 
-const EXCLUDE_ANNOTATION_REF_VIA_INTERFACE = '[disable-awslint:ref-via-interface]';
+const CLASS_ON_PURPOSE_RULE = 'ref-via-interface';
+const L2_INTERFACE_ON_PURPOSE_RULE = 'prefer-ref-interface';
 
 // lint all constructs that are not L1 resources
 export const apiLinter = new Linter(a => ConstructReflection
@@ -11,140 +12,174 @@ export const apiLinter = new Linter(a => ConstructReflection
   .filter(c => !CoreTypes.isCfnResource(c.classType)));
 
 apiLinter.add({
-  code: 'ref-via-interface',
-  message: 'API should use interface and not the concrete class (%s). ' +
-    `If this is intentional, add "${EXCLUDE_ANNOTATION_REF_VIA_INTERFACE}" to element's jsdoc`,
+  code: CLASS_ON_PURPOSE_RULE,
+  message: 'API should use interface (preferably IxxxRef, otherwise Ixxx) and not the concrete class (%s). ' +
+    `If this is intentional, add "${ignoreTag(CLASS_ON_PURPOSE_RULE)}" to element's jsdoc`,
   eval: e => {
-    const cls = e.ctx.classType;
-    const visited = new Set<string>();
+    visitParameters(e.ctx.classType, {
+      visitType: function (type: reflect.TypeReference, docs: reflect.Docs, scope: string): void {
+        // allow exclusion of this rule
+        if (docHasIgnoreTag(docs, CLASS_ON_PURPOSE_RULE)) {
+          return;
+        }
 
-    assertClass(cls);
+        // Assert that all types that reference classes are not resource constructs. Those
+        // should be referenced via Interface.
+        e.assert(!type.type
+          || !type.type.isClassType()
+          || !CoreTypes.isResourceClass(type.type)
+          // Make an exception for `constructs.Construct`.
+          || type.type.fqn === e.ctx.core.baseConstructClassFqn,
+        scope,
+        type.type?.fqn,
+        );
+      },
+    });
+  },
+});
 
-    function assertClass(type: reflect.ClassType): void {
-      if (visited.has(type.fqn)) { return; }
-      visited.add(type.fqn);
+apiLinter.add({
+  code: L2_INTERFACE_ON_PURPOSE_RULE,
+  message: 'API should prefer to use the L1 reference interface (IxxxRef) and not the L2 interface (%s). ' +
+    `If this is intentional, add "${ignoreTag(L2_INTERFACE_ON_PURPOSE_RULE)}" to element's jsdoc`,
+  eval: e => {
+    visitParameters(e.ctx.classType, {
+      visitType: function (type: reflect.TypeReference, docs: reflect.Docs, scope: string): void {
+        // allow exclusion of this rule
+        if (docHasIgnoreTag(docs, L2_INTERFACE_ON_PURPOSE_RULE)) {
+          return;
+        }
 
-      for (const method of type.allMethods) {
-        assertMethod(method);
-      }
+        // Assert that all types that interfaces are not L2 interfaces. This is actually not checking
+        // that they ARE Ref interfaces, just that they aren't L2 interfaces (could also be service-
+        // specific non-resource interfaces, and those are fine too)
+        e.assert(!type.type
+          || !type.type.isInterfaceType()
+          || type.type.datatype
+          || !CoreTypes.isL2Interface(type.type),
+        scope,
+        type.type?.fqn,
+        );
+      },
+    });
+  },
+});
 
-      if (type.initializer) {
-        assertMethod(type.initializer);
-      }
+function ignoreTag(rule: string) {
+  return `[disable-awslint:${rule}]`;
+}
+
+function docHasIgnoreTag(docs: reflect.Docs, rule: string) {
+  const tag = ignoreTag(rule);
+  return docs.summary.includes(tag) || docs.remarks.includes(tag);
+}
+
+/**
+ * Visit all types in the API of a given type
+ *
+ * This visits method parameters and members of structs of method parameters.
+ */
+function visitParameters(root: reflect.Type, visitor: TypeVisitor) {
+  const visited = new Set<string>();
+
+  if (root.isClassType()) {
+    assertClass(root);
+  } else if (root.isInterfaceType()) {
+    assertInterface(root);
+  } else {
+    throw new Error(`invalid type: ${root.toString()}`);
+  }
+
+  function assertClass(type: reflect.ClassType): void {
+    if (visited.has(type.fqn)) { return; }
+    visited.add(type.fqn);
+
+    for (const method of type.allMethods) {
+      assertMethod(method);
     }
 
-    function assertDataType(type: reflect.InterfaceType): void {
-      for (const property of type.allProperties) {
-        assertProperty(property);
-      }
+    if (type.initializer) {
+      assertMethod(type.initializer);
     }
+  }
 
-    function assertInterface(type: reflect.InterfaceType): void {
-      if (visited.has(type.fqn)) { return; }
-      visited.add(type.fqn);
-
-      if (type.datatype) {
-        assertDataType(type);
-      }
-
-      for (const method of type.allMethods) {
-        assertMethod(method);
-      }
+  function assertDataType(type: reflect.InterfaceType): void {
+    for (const property of type.allProperties) {
+      assertProperty(property);
     }
+  }
 
-    function assertProperty(property: reflect.Property) {
-      if (property.protected) {
-        return;
-      }
+  function assertInterface(type: reflect.InterfaceType): void {
+    if (visited.has(type.fqn)) { return; }
+    visited.add(type.fqn);
 
-      const site = property.overrides ? property.overrides : property.parentType;
-      assertType(property.type, property.docs, `${site.fqn}.${property.name}`);
+    if (type.datatype) {
+      assertDataType(type);
     }
 
-    function assertMethod(method: reflect.Callable) {
-      if (method.protected) {
-        return;
-      }
-
-      const site = method.overrides ? method.overrides : method.parentType;
-      const scope = `${site.fqn}.${method.name}`;
-
-      let firstMethod: reflect.Callable | undefined = site.isClassType() || site.isInterfaceType()
-        ? site.allMethods.find(m => m.name === method.name)
-        : undefined;
-
-      if (!firstMethod) {
-        firstMethod = method;
-      }
-
-      for (const param of firstMethod.parameters) {
-        assertType(param.type, param.docs, `${scope}.${param.name}`);
-      }
-
-      // note that we do not require that return values will use an interface
+    for (const method of type.allMethods) {
+      assertMethod(method);
     }
+  }
 
-    function assertType(type: reflect.TypeReference, docs: reflect.Docs, scope: string): void {
-      if (type.primitive) {
-        return;
-      }
+  function assertProperty(property: reflect.Property) {
+    if (property.protected) {
+      return;
+    }
 
-      if (type.void) {
-        return;
-      }
+    const site = property.overrides ? property.overrides : property.parentType;
+    assertType(property.type, property.docs, `${site.fqn}.${property.name}`);
+  }
 
-      if (type.arrayOfType) {
-        return assertType(type.arrayOfType, docs, scope);
-      }
+  function assertMethod(method: reflect.Callable) {
+    if (method.protected) {
+      return;
+    }
 
-      if (type.mapOfType) {
-        return assertType(type.mapOfType, docs, scope);
-      }
+    const site = method.overrides ? method.overrides : method.parentType;
+    const scope = `${site.fqn}.${method.name}`;
 
-      if (type.unionOfTypes) {
-        for (const t of type.unionOfTypes) {
-          assertType(t, docs, scope);
-        }
-        return;
-      }
+    let firstMethod: reflect.Callable | undefined = site.isClassType() || site.isInterfaceType()
+      ? site.allMethods.find(m => m.name === method.name)
+      : undefined;
 
-      if (type.intersectionOfTypes) {
-        for (const t of type.intersectionOfTypes) {
-          assertType(t, docs, scope);
-        }
-        return;
-      }
+    if (!firstMethod) {
+      firstMethod = method;
+    }
 
-      // interfaces are okay
-      if (type.type && type.type.isInterfaceType()) {
-        return assertInterface(type.type);
-      }
+    for (const param of firstMethod.parameters) {
+      assertType(param.type, param.docs, `${scope}.${param.name}`);
+    }
 
-      // enums are okay
-      if (type.type && type.type.isEnumType()) {
-        return;
-      }
+    // note that we do not require that return values will use an interface
+  }
 
-      // classes are okay as long as they are not resource constructs
-      if (type.type && type.type.isClassType()) {
-        if (!CoreTypes.isResourceClass(type.type)) {
-          return;
-        }
+  function assertType(type: reflect.TypeReference, docs: reflect.Docs, scope: string): void {
+    visitor.visitType(type, docs, scope);
 
-        if (type.type.fqn === e.ctx.core.baseConstructClassFqn) {
-          return;
-        }
+    // And recurse
+    if (type.arrayOfType) {
+      return assertType(type.arrayOfType, docs, scope);
+    }
 
-        // allow exclusion of this rule
-        if (docs.summary.includes(EXCLUDE_ANNOTATION_REF_VIA_INTERFACE) || docs.remarks.includes(EXCLUDE_ANNOTATION_REF_VIA_INTERFACE)) {
-          return;
-        }
+    if (type.mapOfType) {
+      return assertType(type.mapOfType, docs, scope);
+    }
 
-        e.assert(false, scope, type.type.fqn);
-        return;
+    if (type.unionOfTypes) {
+      for (const t of type.unionOfTypes) {
+        assertType(t, docs, scope);
       }
+      return;
+    }
 
-      throw new Error(`invalid type reference: ${type.toString()}`);
+    // interfaces are okay
+    if (type.type && type.type.isInterfaceType()) {
+      return assertInterface(type.type);
     }
-  },
-});
+  }
+}
+
+interface TypeVisitor {
+  visitType(type: reflect.TypeReference, docs: reflect.Docs, scope: string): void;
+}

package/lib/rules/core-types.d.ts

@@ -25,6 +25,14 @@ export declare class CoreTypes {
      * @returns true if `classType` represents an AWS resource (i.e. extends `cdk.Resource`).
      */
     static isResourceClass(classType: reflect.ClassType): string | true | undefined;
+    /**
+     * @returns true if `interfaceType` looks like an L2 interface (`IBucket`)
+     */
+    static isL2Interface(interfaceType: reflect.InterfaceType): boolean;
+    /**
+     * @returns true if `interfaceType` looks like an L1 Ref interface (`IBucketRef)`
+     */
+    static isL1RefInterface(interfaceType: reflect.InterfaceType): boolean;
     /**
      * Return true if the nesting parent of the given interface is a CFN class
      */

package/lib/rules/core-types.js

@@ -62,6 +62,22 @@ class CoreTypes {
         const baseResource = classType.system.findClass(CoreTypesFqn.Resource);
         return classType.extends(baseResource) || (0, util_1.getDocTag)(classType, 'resource');
     }
+    /**
+     * @returns true if `interfaceType` looks like an L2 interface (`IBucket`)
+     */
+    static isL2Interface(interfaceType) {
+        // We determine this by it being a behavioral interface, and it inheriting from `IResource`.
+        const baseInterface = interfaceType.system.findInterface(CoreTypesFqn.ResourceInterface);
+        return !interfaceType.datatype && interfaceExtends(interfaceType, baseInterface);
+    }
+    /**
+     * @returns true if `interfaceType` looks like an L1 Ref interface (`IBucketRef)`
+     */
+    static isL1RefInterface(interfaceType) {
+        // We determine this by it being a behavioral interface, and it living inside the `aws-cdk-lib.interfaces` namespace
+        // with a name ending in `Ref`.
+        return !interfaceType.datatype && interfaceType.fqn.startsWith('aws-cdk-lib.interfaces.') && interfaceType.name.endsWith('Ref');
+    }
     /**
      * Return true if the nesting parent of the given interface is a CFN class
      */
@@ -183,4 +199,7 @@ class CoreTypes {
     }
 }
 exports.CoreTypes = CoreTypes;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"core-types.js","sourceRoot":"","sources":["core-types.ts"],"names":[],"mappings":"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","sourcesContent":["import * as reflect from 'jsii-reflect';\nimport { getDocTag } from './util';\n\nconst CORE_MODULE = 'aws-cdk-lib';\nenum CoreTypesFqn {\n  CfnResource = 'aws-cdk-lib.CfnResource',\n  Resource = 'aws-cdk-lib.Resource',\n  ResourceInterface = 'aws-cdk-lib.IResource',\n  ResolvableInterface = 'aws-cdk-lib.IResolvable',\n  PhysicalName = 'aws-cdk-lib.PhysicalName',\n\n  Construct = 'constructs.Construct',\n  ConstructInterface = 'constructs.IConstruct',\n}\n\nexport class CoreTypes {\n  /**\n   * @returns true if assembly has the Core module\n   */\n  public static hasCoreModule(assembly: reflect.Assembly) {\n    return (!assembly.system.assemblies.find(a => a.name === CORE_MODULE));\n  }\n\n  /**\n   * @returns true if `classType` represents an L1 Cfn Resource\n   */\n  public static isCfnResource(c: reflect.ClassType) {\n    if (!c.system.includesAssembly(CORE_MODULE)) {\n      return false;\n    }\n\n    // skip CfnResource itself\n    if (c.fqn === CoreTypesFqn.CfnResource) {\n      return false;\n    }\n\n    if (!this.isConstructClass(c)) {\n      return false;\n    }\n\n    const cfnResourceClass = c.system.findFqn(CoreTypesFqn.CfnResource);\n    if (!c.extends(cfnResourceClass)) {\n      return false;\n    }\n\n    return c.name.startsWith('Cfn');\n  }\n\n  /**\n   * @returns true if `classType` represents a Construct\n   */\n  public static isConstructClass(c: reflect.ClassType) {\n    if (!c.system.includesAssembly(CORE_MODULE)) {\n      return false;\n    }\n\n    if (!c.isClassType()) {\n      return false;\n    }\n\n    if (c.abstract) {\n      return false;\n    }\n\n    return c.extends(c.system.findFqn(CoreTypesFqn.Construct));\n  }\n\n  /**\n   * @returns true if `classType` represents an AWS resource (i.e. extends `cdk.Resource`).\n   */\n  public static isResourceClass(classType: reflect.ClassType) {\n    const baseResource = classType.system.findClass(CoreTypesFqn.Resource);\n    return classType.extends(baseResource) || getDocTag(classType, 'resource');\n  }\n\n  /**\n   * Return true if the nesting parent of the given interface is a CFN class\n   */\n  public static isCfnNestedType(interfaceType: reflect.Type) {\n    return interfaceType.nestingParent && CoreTypes.isCfnType(interfaceType.nestingParent);\n  }\n\n  /**\n   * Return true if the given interface type is a CFN class, prop type or interface\n   */\n  public static isCfnType(interfaceType: reflect.Type): boolean {\n    // aws_service.CfnTheResource\n    if (interfaceType.name.startsWith('Cfn')) {\n      return true;\n    }\n\n    // aws_service.ITheResourceRf\n    if (/^I\\w+Ref/.test(interfaceType.name)) {\n      return true;\n    }\n\n    if (interfaceType.namespace) {\n      if (interfaceType.namespace.startsWith('Cfn')) {\n        return true;\n      }\n\n      const namespaceParts = interfaceType.namespace.split('.');\n\n      // aws_service.CfnTheResource.SubType\n      if (namespaceParts.at(1)?.startsWith('Cfn')) {\n        return true;\n      }\n\n      // aws_service.mixins.CfnTheResource.SubType\n      if (namespaceParts.at(1) === 'mixins' && namespaceParts.at(2)?.startsWith('Cfn')) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n\n  /**\n   * @returns `classType` for the core type Construct\n   * @deprecated - use `baseConstructClass()`\n   */\n  public get constructClass() {\n    return this.baseConstructClass;\n  }\n\n  /**\n   * @returns `classType` for the core type Construct\n   */\n  public get baseConstructClass() {\n    return this.sys.findClass(this.baseConstructClassFqn);\n  }\n\n  /**\n   * @returns `classType` for the core type Construct\n   */\n  public get baseConstructClassFqn() {\n    return CoreTypesFqn.Construct;\n  }\n\n  /**\n   * @returns `interfacetype` for the core type Construct\n   * @deprecated - use `baseConstructInterface()`\n   */\n  public get constructInterface() {\n    return this.baseConstructInterface;\n  }\n\n  /**\n   * @returns `interfacetype` for the core type Construct\n   */\n  public get baseConstructInterface() {\n    return this.sys.findInterface(this.baseConstructInterfaceFqn);\n  }\n\n  /**\n   * @returns fqn for for the core Construct interface\n   */\n  public get baseConstructInterfaceFqn() {\n    return CoreTypesFqn.ConstructInterface;\n  }\n\n  /**\n   * @returns `classType` for the core type Resource\n   */\n  public get resourceClass() {\n    return this.sys.findClass(this.resourceClassFqn);\n  }\n\n  /**\n   * @returns fqn for the core type Resource\n   */\n  public get resourceClassFqn() {\n    return CoreTypesFqn.Resource;\n  }\n\n  /**\n   * @returns fqn for the core Resource interface\n   */\n  public get resourceInterface() {\n    return this.sys.findInterface(this.resourceInterfaceFqn);\n  }\n\n  /**\n   * @returns `interfaceType` for the core type Resource\n   */\n  public get resourceInterfaceFqn() {\n    return CoreTypesFqn.ResourceInterface;\n  }\n\n  /**\n   * @returns `classType` for the core type Token\n   */\n  public get tokenInterface() {\n    return this.sys.findInterface(this.tokenInterfaceFqn);\n  }\n\n  /**\n   * @returns fqn for the core type Token\n   */\n  public get tokenInterfaceFqn() {\n    return CoreTypesFqn.ResolvableInterface;\n  }\n\n  public get physicalNameClass() {\n    return this.sys.findClass(CoreTypesFqn.PhysicalName);\n  }\n\n  private readonly sys: reflect.TypeSystem;\n\n  constructor(sys: reflect.TypeSystem) {\n    this.sys = sys;\n    if (!sys.includesAssembly(CORE_MODULE)) {\n      // disable-all-checks\n      return;\n    }\n  }\n}\n"]}
+function interfaceExtends(interfaceType, baseInterface) {
+    return interfaceType.getInterfaces(true).some(i => i.fqn === baseInterface.fqn);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"core-types.js","sourceRoot":"","sources":["core-types.ts"],"names":[],"mappings":";;;AACA,iCAAmC;AAEnC,MAAM,WAAW,GAAG,aAAa,CAAC;AAClC,IAAK,YASJ;AATD,WAAK,YAAY;IACf,uDAAuC,CAAA;IACvC,iDAAiC,CAAA;IACjC,2DAA2C,CAAA;IAC3C,+DAA+C,CAAA;IAC/C,yDAAyC,CAAA;IAEzC,kDAAkC,CAAA;IAClC,4DAA4C,CAAA;AAC9C,CAAC,EATI,YAAY,KAAZ,YAAY,QAShB;AAED,MAAa,SAAS;IACpB;;OAEG;IACI,MAAM,CAAC,aAAa,CAAC,QAA0B;QACpD,OAAO,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,WAAW,CAAC,CAAC,CAAC;IACzE,CAAC;IAED;;OAEG;IACI,MAAM,CAAC,aAAa,CAAC,CAAoB;QAC9C,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,gBAAgB,CAAC,WAAW,CAAC,EAAE,CAAC;YAC5C,OAAO,KAAK,CAAC;QACf,CAAC;QAED,0BAA0B;QAC1B,IAAI,CAAC,CAAC,GAAG,KAAK,YAAY,CAAC,WAAW,EAAE,CAAC;YACvC,OAAO,KAAK,CAAC;QACf,CAAC;QAED,IAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC,EAAE,CAAC;YAC9B,OAAO,KAAK,CAAC;QACf,CAAC;QAED,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,YAAY,CAAC,WAAW,CAAC,CAAC;QACpE,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,gBAAgB,CAAC,EAAE,CAAC;YACjC,OAAO,KAAK,CAAC;QACf,CAAC;QAED,OAAO,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;IAClC,CAAC;IAED;;OAEG;IACI,MAAM,CAAC,gBAAgB,CAAC,CAAoB;QACjD,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,gBAAgB,CAAC,WAAW,CAAC,EAAE,CAAC;YAC5C,OAAO,KAAK,CAAC;QACf,CAAC;QAED,IAAI,CAAC,CAAC,CAAC,WAAW,EAAE,EAAE,CAAC;YACrB,OAAO,KAAK,CAAC;QACf,CAAC;QAED,IAAI,CAAC,CAAC,QAAQ,EAAE,CAAC;YACf,OAAO,KAAK,CAAC;QACf,CAAC;QAED,OAAO,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC,CAAC;IAC7D,CAAC;IAED;;OAEG;IACI,MAAM,CAAC,eAAe,CAAC,SAA4B;QACxD,MAAM,YAAY,GAAG,SAAS,CAAC,MAAM,CAAC,SAAS,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC;QACvE,OAAO,SAAS,CAAC,OAAO,CAAC,YAAY,CAAC,IAAI,IAAA,gBAAS,EAAC,SAAS,EAAE,UAAU,CAAC,CAAC;IAC7E,CAAC;IAED;;OAEG;IACI,MAAM,CAAC,aAAa,CAAC,aAAoC;QAC9D,4FAA4F;QAC5F,MAAM,aAAa,GAAG,aAAa,CAAC,MAAM,CAAC,aAAa,CAAC,YAAY,CAAC,iBAAiB,CAAC,CAAC;QACzF,OAAO,CAAC,aAAa,CAAC,QAAQ,IAAI,gBAAgB,CAAC,aAAa,EAAE,aAAa,CAAC,CAAC;IACnF,CAAC;IAED;;OAEG;IACI,MAAM,CAAC,gBAAgB,CAAC,aAAoC;QACjE,oHAAoH;QACpH,+BAA+B;QAC/B,OAAO,CAAC,aAAa,CAAC,QAAQ,IAAI,aAAa,CAAC,GAAG,CAAC,UAAU,CAAC,yBAAyB,CAAC,IAAI,aAAa,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IAClI,CAAC;IAED;;OAEG;IACI,MAAM,CAAC,eAAe,CAAC,aAA2B;QACvD,OAAO,aAAa,CAAC,aAAa,IAAI,SAAS,CAAC,SAAS,CAAC,aAAa,CAAC,aAAa,CAAC,CAAC;IACzF,CAAC;IAED;;OAEG;IACI,MAAM,CAAC,SAAS,CAAC,aAA2B;QACjD,6BAA6B;QAC7B,IAAI,aAAa,CAAC,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE,CAAC;YACzC,OAAO,IAAI,CAAC;QACd,CAAC;QAED,6BAA6B;QAC7B,IAAI,UAAU,CAAC,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,EAAE,CAAC;YACxC,OAAO,IAAI,CAAC;QACd,CAAC;QAED,IAAI,aAAa,CAAC,SAAS,EAAE,CAAC;YAC5B,IAAI,aAAa,CAAC,SAAS,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE,CAAC;gBAC9C,OAAO,IAAI,CAAC;YACd,CAAC;YAED,MAAM,cAAc,GAAG,aAAa,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;YAE1D,qCAAqC;YACrC,IAAI,cAAc,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,UAAU,CAAC,KAAK,CAAC,EAAE,CAAC;gBAC5C,OAAO,IAAI,CAAC;YACd,CAAC;YAED,4CAA4C;YAC5C,IAAI,cAAc,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,QAAQ,IAAI,cAAc,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,UAAU,CAAC,KAAK,CAAC,EAAE,CAAC;gBACjF,OAAO,IAAI,CAAC;YACd,CAAC;QACH,CAAC;QAED,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;;OAGG;IACH,IAAW,cAAc;QACvB,OAAO,IAAI,CAAC,kBAAkB,CAAC;IACjC,CAAC;IAED;;OAEG;IACH,IAAW,kBAAkB;QAC3B,OAAO,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,CAAC,qBAAqB,CAAC,CAAC;IACxD,CAAC;IAED;;OAEG;IACH,IAAW,qBAAqB;QAC9B,OAAO,YAAY,CAAC,SAAS,CAAC;IAChC,CAAC;IAED;;;OAGG;IACH,IAAW,kBAAkB;QAC3B,OAAO,IAAI,CAAC,sBAAsB,CAAC;IACrC,CAAC;IAED;;OAEG;IACH,IAAW,sBAAsB;QAC/B,OAAO,IAAI,CAAC,GAAG,CAAC,aAAa,CAAC,IAAI,CAAC,yBAAyB,CAAC,CAAC;IAChE,CAAC;IAED;;OAEG;IACH,IAAW,yBAAyB;QAClC,OAAO,YAAY,CAAC,kBAAkB,CAAC;IACzC,CAAC;IAED;;OAEG;IACH,IAAW,aAAa;QACtB,OAAO,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;IACnD,CAAC;IAED;;OAEG;IACH,IAAW,gBAAgB;QACzB,OAAO,YAAY,CAAC,QAAQ,CAAC;IAC/B,CAAC;IAED;;OAEG;IACH,IAAW,iBAAiB;QAC1B,OAAO,IAAI,CAAC,GAAG,CAAC,aAAa,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC;IAC3D,CAAC;IAED;;OAEG;IACH,IAAW,oBAAoB;QAC7B,OAAO,YAAY,CAAC,iBAAiB,CAAC;IACxC,CAAC;IAED;;OAEG;IACH,IAAW,cAAc;QACvB,OAAO,IAAI,CAAC,GAAG,CAAC,aAAa,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC;IACxD,CAAC;IAED;;OAEG;IACH,IAAW,iBAAiB;QAC1B,OAAO,YAAY,CAAC,mBAAmB,CAAC;IAC1C,CAAC;IAED,IAAW,iBAAiB;QAC1B,OAAO,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,YAAY,CAAC,YAAY,CAAC,CAAC;IACvD,CAAC;IAEgB,GAAG,CAAqB;IAEzC,YAAY,GAAuB;QACjC,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC;QACf,IAAI,CAAC,GAAG,CAAC,gBAAgB,CAAC,WAAW,CAAC,EAAE,CAAC;YACvC,qBAAqB;YACrB,OAAO;QACT,CAAC;IACH,CAAC;CACF;AA3ND,8BA2NC;AAED,SAAS,gBAAgB,CAAC,aAAoC,EAAE,aAAoC;IAClG,OAAO,aAAa,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,KAAK,aAAa,CAAC,GAAG,CAAC,CAAC;AAClF,CAAC","sourcesContent":["import * as reflect from 'jsii-reflect';\nimport { getDocTag } from './util';\n\nconst CORE_MODULE = 'aws-cdk-lib';\nenum CoreTypesFqn {\n  CfnResource = 'aws-cdk-lib.CfnResource',\n  Resource = 'aws-cdk-lib.Resource',\n  ResourceInterface = 'aws-cdk-lib.IResource',\n  ResolvableInterface = 'aws-cdk-lib.IResolvable',\n  PhysicalName = 'aws-cdk-lib.PhysicalName',\n\n  Construct = 'constructs.Construct',\n  ConstructInterface = 'constructs.IConstruct',\n}\n\nexport class CoreTypes {\n  /**\n   * @returns true if assembly has the Core module\n   */\n  public static hasCoreModule(assembly: reflect.Assembly) {\n    return (!assembly.system.assemblies.find(a => a.name === CORE_MODULE));\n  }\n\n  /**\n   * @returns true if `classType` represents an L1 Cfn Resource\n   */\n  public static isCfnResource(c: reflect.ClassType) {\n    if (!c.system.includesAssembly(CORE_MODULE)) {\n      return false;\n    }\n\n    // skip CfnResource itself\n    if (c.fqn === CoreTypesFqn.CfnResource) {\n      return false;\n    }\n\n    if (!this.isConstructClass(c)) {\n      return false;\n    }\n\n    const cfnResourceClass = c.system.findFqn(CoreTypesFqn.CfnResource);\n    if (!c.extends(cfnResourceClass)) {\n      return false;\n    }\n\n    return c.name.startsWith('Cfn');\n  }\n\n  /**\n   * @returns true if `classType` represents a Construct\n   */\n  public static isConstructClass(c: reflect.ClassType) {\n    if (!c.system.includesAssembly(CORE_MODULE)) {\n      return false;\n    }\n\n    if (!c.isClassType()) {\n      return false;\n    }\n\n    if (c.abstract) {\n      return false;\n    }\n\n    return c.extends(c.system.findFqn(CoreTypesFqn.Construct));\n  }\n\n  /**\n   * @returns true if `classType` represents an AWS resource (i.e. extends `cdk.Resource`).\n   */\n  public static isResourceClass(classType: reflect.ClassType) {\n    const baseResource = classType.system.findClass(CoreTypesFqn.Resource);\n    return classType.extends(baseResource) || getDocTag(classType, 'resource');\n  }\n\n  /**\n   * @returns true if `interfaceType` looks like an L2 interface (`IBucket`)\n   */\n  public static isL2Interface(interfaceType: reflect.InterfaceType) {\n    // We determine this by it being a behavioral interface, and it inheriting from `IResource`.\n    const baseInterface = interfaceType.system.findInterface(CoreTypesFqn.ResourceInterface);\n    return !interfaceType.datatype && interfaceExtends(interfaceType, baseInterface);\n  }\n\n  /**\n   * @returns true if `interfaceType` looks like an L1 Ref interface (`IBucketRef)`\n   */\n  public static isL1RefInterface(interfaceType: reflect.InterfaceType) {\n    // We determine this by it being a behavioral interface, and it living inside the `aws-cdk-lib.interfaces` namespace\n    // with a name ending in `Ref`.\n    return !interfaceType.datatype && interfaceType.fqn.startsWith('aws-cdk-lib.interfaces.') && interfaceType.name.endsWith('Ref');\n  }\n\n  /**\n   * Return true if the nesting parent of the given interface is a CFN class\n   */\n  public static isCfnNestedType(interfaceType: reflect.Type) {\n    return interfaceType.nestingParent && CoreTypes.isCfnType(interfaceType.nestingParent);\n  }\n\n  /**\n   * Return true if the given interface type is a CFN class, prop type or interface\n   */\n  public static isCfnType(interfaceType: reflect.Type): boolean {\n    // aws_service.CfnTheResource\n    if (interfaceType.name.startsWith('Cfn')) {\n      return true;\n    }\n\n    // aws_service.ITheResourceRf\n    if (/^I\\w+Ref/.test(interfaceType.name)) {\n      return true;\n    }\n\n    if (interfaceType.namespace) {\n      if (interfaceType.namespace.startsWith('Cfn')) {\n        return true;\n      }\n\n      const namespaceParts = interfaceType.namespace.split('.');\n\n      // aws_service.CfnTheResource.SubType\n      if (namespaceParts.at(1)?.startsWith('Cfn')) {\n        return true;\n      }\n\n      // aws_service.mixins.CfnTheResource.SubType\n      if (namespaceParts.at(1) === 'mixins' && namespaceParts.at(2)?.startsWith('Cfn')) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n\n  /**\n   * @returns `classType` for the core type Construct\n   * @deprecated - use `baseConstructClass()`\n   */\n  public get constructClass() {\n    return this.baseConstructClass;\n  }\n\n  /**\n   * @returns `classType` for the core type Construct\n   */\n  public get baseConstructClass() {\n    return this.sys.findClass(this.baseConstructClassFqn);\n  }\n\n  /**\n   * @returns `classType` for the core type Construct\n   */\n  public get baseConstructClassFqn() {\n    return CoreTypesFqn.Construct;\n  }\n\n  /**\n   * @returns `interfacetype` for the core type Construct\n   * @deprecated - use `baseConstructInterface()`\n   */\n  public get constructInterface() {\n    return this.baseConstructInterface;\n  }\n\n  /**\n   * @returns `interfacetype` for the core type Construct\n   */\n  public get baseConstructInterface() {\n    return this.sys.findInterface(this.baseConstructInterfaceFqn);\n  }\n\n  /**\n   * @returns fqn for for the core Construct interface\n   */\n  public get baseConstructInterfaceFqn() {\n    return CoreTypesFqn.ConstructInterface;\n  }\n\n  /**\n   * @returns `classType` for the core type Resource\n   */\n  public get resourceClass() {\n    return this.sys.findClass(this.resourceClassFqn);\n  }\n\n  /**\n   * @returns fqn for the core type Resource\n   */\n  public get resourceClassFqn() {\n    return CoreTypesFqn.Resource;\n  }\n\n  /**\n   * @returns fqn for the core Resource interface\n   */\n  public get resourceInterface() {\n    return this.sys.findInterface(this.resourceInterfaceFqn);\n  }\n\n  /**\n   * @returns `interfaceType` for the core type Resource\n   */\n  public get resourceInterfaceFqn() {\n    return CoreTypesFqn.ResourceInterface;\n  }\n\n  /**\n   * @returns `classType` for the core type Token\n   */\n  public get tokenInterface() {\n    return this.sys.findInterface(this.tokenInterfaceFqn);\n  }\n\n  /**\n   * @returns fqn for the core type Token\n   */\n  public get tokenInterfaceFqn() {\n    return CoreTypesFqn.ResolvableInterface;\n  }\n\n  public get physicalNameClass() {\n    return this.sys.findClass(CoreTypesFqn.PhysicalName);\n  }\n\n  private readonly sys: reflect.TypeSystem;\n\n  constructor(sys: reflect.TypeSystem) {\n    this.sys = sys;\n    if (!sys.includesAssembly(CORE_MODULE)) {\n      // disable-all-checks\n      return;\n    }\n  }\n}\n\nfunction interfaceExtends(interfaceType: reflect.InterfaceType, baseInterface: reflect.InterfaceType) {\n  return interfaceType.getInterfaces(true).some(i => i.fqn === baseInterface.fqn);\n}\n"]}

package/lib/rules/core-types.ts

@@ -73,6 +73,24 @@ export class CoreTypes {
     return classType.extends(baseResource) || getDocTag(classType, 'resource');
   }
 
+  /**
+   * @returns true if `interfaceType` looks like an L2 interface (`IBucket`)
+   */
+  public static isL2Interface(interfaceType: reflect.InterfaceType) {
+    // We determine this by it being a behavioral interface, and it inheriting from `IResource`.
+    const baseInterface = interfaceType.system.findInterface(CoreTypesFqn.ResourceInterface);
+    return !interfaceType.datatype && interfaceExtends(interfaceType, baseInterface);
+  }
+
+  /**
+   * @returns true if `interfaceType` looks like an L1 Ref interface (`IBucketRef)`
+   */
+  public static isL1RefInterface(interfaceType: reflect.InterfaceType) {
+    // We determine this by it being a behavioral interface, and it living inside the `aws-cdk-lib.interfaces` namespace
+    // with a name ending in `Ref`.
+    return !interfaceType.datatype && interfaceType.fqn.startsWith('aws-cdk-lib.interfaces.') && interfaceType.name.endsWith('Ref');
+  }
+
   /**
    * Return true if the nesting parent of the given interface is a CFN class
    */
@@ -215,3 +233,7 @@ export class CoreTypes {
     }
   }
 }
+
+function interfaceExtends(interfaceType: reflect.InterfaceType, baseInterface: reflect.InterfaceType) {
+  return interfaceType.getInterfaces(true).some(i => i.fqn === baseInterface.fqn);
+}

package/lib/rules/grant-methods.d.ts

@@ -0,0 +1,2 @@
+import { Linter } from '../linter';
+export declare const grantsMethodsLinter: Linter<import("jsii-reflect").ClassType>;

package/lib/rules/grant-methods.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.grantsMethodsLinter = void 0;
+const linter_1 = require("../linter");
+const EXCLUDE_ANNOTATION_NO_GRANTS = '[disable-awslint:no-grants]';
+exports.grantsMethodsLinter = new linter_1.Linter(assembly => assembly.allClasses);
+exports.grantsMethodsLinter.add({
+    code: 'no-grants',
+    message: 'L2 constructs are not allowed to have new "grantXxx()" methods. Create or re-use a companion <Contruct>Grants class instead.',
+    eval: e => {
+        Object.values(e.ctx.getMethods())
+            .filter(m => !m.static)
+            .filter(m => !m.abstract)
+            .filter(m => m.name.startsWith('grant') && m.name !== 'grantOnKey')
+            .filter(m => m.parameters.length > 0 && m.parameters[0].type.fqn === 'aws-cdk-lib.aws_iam.IGrantable')
+            .forEach((grant) => {
+            e.assert(isExempted(grant), `${e.ctx.fqn}.${grant.name}`);
+        });
+    },
+});
+function isExempted(method) {
+    const docs = method.docs;
+    return [docs.summary, docs.remarks].some(doc => doc.includes(EXCLUDE_ANNOTATION_NO_GRANTS));
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/rules/grant-methods.ts

@@ -0,0 +1,26 @@
+import { Method } from 'jsii-reflect';
+import { Linter } from '../linter';
+
+const EXCLUDE_ANNOTATION_NO_GRANTS = '[disable-awslint:no-grants]';
+
+export const grantsMethodsLinter = new Linter(assembly => assembly.allClasses);
+
+grantsMethodsLinter.add({
+  code: 'no-grants',
+  message: 'L2 constructs are not allowed to have new "grantXxx()" methods. Create or re-use a companion <Contruct>Grants class instead.',
+  eval: e => {
+    Object.values(e.ctx.getMethods())
+      .filter(m => !m.static)
+      .filter(m => !m.abstract)
+      .filter(m => m.name.startsWith('grant') && m.name !== 'grantOnKey')
+      .filter(m => m.parameters.length > 0 && m.parameters[0].type.fqn === 'aws-cdk-lib.aws_iam.IGrantable')
+      .forEach((grant) => {
+        e.assert(isExempted(grant), `${e.ctx.fqn}.${grant.name}`);
+      });
+  },
+});
+
+function isExempted(method: Method): boolean {
+  const docs = method.docs;
+  return [docs.summary, docs.remarks].some(doc => doc.includes(EXCLUDE_ANNOTATION_NO_GRANTS));
+}

package/lib/rules/index.js

@@ -16,5 +16,6 @@ const no_unused_type_1 = require("./no-unused-type");
 const public_static_properties_1 = require("./public-static-properties");
 const resource_1 = require("./resource");
 const linter_1 = require("../linter");
-exports.ALL_RULES_LINTER = new linter_1.AggregateLinter(module_1.moduleLinter, construct_1.constructLinter, cfn_resource_1.cfnResourceLinter, resource_1.resourceLinter, api_1.apiLinter, imports_1.importsLinter, attributes_1.attributesLinter, exports_1.exportsLinter, cloudwatch_events_1.eventsLinter, integrations_1.integrationLinter, no_unused_type_1.noUnusedTypeLinter, durations_1.durationsLinter, public_static_properties_1.publicStaticPropertiesLinter, docs_1.docsLinter);
-//# sourceMappingURL=data:application/json;base64,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
+const grant_methods_1 = require("./grant-methods");
+exports.ALL_RULES_LINTER = new linter_1.AggregateLinter(module_1.moduleLinter, construct_1.constructLinter, cfn_resource_1.cfnResourceLinter, resource_1.resourceLinter, api_1.apiLinter, imports_1.importsLinter, attributes_1.attributesLinter, exports_1.exportsLinter, cloudwatch_events_1.eventsLinter, integrations_1.integrationLinter, no_unused_type_1.noUnusedTypeLinter, durations_1.durationsLinter, public_static_properties_1.publicStaticPropertiesLinter, docs_1.docsLinter, grant_methods_1.grantsMethodsLinter);
+//# sourceMappingURL=data:application/json;base64,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

package/lib/rules/index.ts

@@ -13,6 +13,7 @@ import { noUnusedTypeLinter } from './no-unused-type';
 import { publicStaticPropertiesLinter } from './public-static-properties';
 import { resourceLinter } from './resource';
 import { AggregateLinter } from '../linter';
+import { grantsMethodsLinter } from './grant-methods';
 
 export const ALL_RULES_LINTER = new AggregateLinter(
   moduleLinter,
@@ -29,4 +30,5 @@ export const ALL_RULES_LINTER = new AggregateLinter(
   durationsLinter,
   publicStaticPropertiesLinter,
   docsLinter,
+  grantsMethodsLinter,
 );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "awslint",
-  "version": "2.234.0-alpha.0",
+  "version": "2.235.0-alpha.0",
   "description": "Enforces the AWS Construct Library guidelines",
   "scripts": {
     "build": "tsc -b && eslint && pkglint && chmod +x bin/awslint",
@@ -26,8 +26,8 @@
     "yargs": "^16.2.0"
   },
   "devDependencies": {
-    "@aws-cdk/eslint-config": "2.234.0-alpha.0",
-    "@aws-cdk/pkglint": "2.234.0-alpha.0",
+    "@aws-cdk/eslint-config": "2.235.0-alpha.0",
+    "@aws-cdk/pkglint": "2.235.0-alpha.0",
     "@types/fs-extra": "^9.0.13",
     "@types/jest": "^29.5.14",
     "@types/yargs": "^15.0.20",