eslint-cdk-plugin 3.4.0 → 3.4.2

package/dist/index.cjs

@@ -26,7 +26,7 @@ function _interopNamespaceDefault(e) {
 var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
 
 var name = "eslint-cdk-plugin";
-var version = "3.4.0";
+var version = "3.4.2";
 
 const createRule = utils.ESLintUtils.RuleCreator(
   (name) => `https://eslint-cdk-plugin.dev/rules/${name}`
@@ -153,6 +153,46 @@ const SYNTAX_KIND = {
   PROPERTY_ACCESS_EXPRESSION: 211
 };
 
+const getSymbol = (type) => {
+  return type.getSymbol?.() ?? type.symbol;
+};
+const isClassType = (type) => {
+  return getSymbol(type)?.flags === SYMBOL_FLAGS.CLASS;
+};
+const isArrayType = (type) => {
+  const symbol = getSymbol(type);
+  if (symbol?.name === "Array") return true;
+  if ("target" in type && type.target) {
+    const targetSymbol = getSymbol(type.target);
+    return targetSymbol?.name === "Array";
+  }
+  return false;
+};
+
+const getArrayElementType = (type) => {
+  if (!isArrayType(type)) return void 0;
+  if ("typeArguments" in type && Array.isArray(type.typeArguments)) {
+    return type.typeArguments[0];
+  }
+  return void 0;
+};
+
+const getGenericTypeArgument = (type) => {
+  if ("aliasSymbol" in type && type.aliasSymbol && "aliasTypeArguments" in type && type.aliasTypeArguments?.length) {
+    return type.aliasTypeArguments[0];
+  }
+  if ("typeArguments" in type && Array.isArray(type.typeArguments) && type.typeArguments?.length) {
+    return type.typeArguments[0];
+  }
+  if ("target" in type && type.target && "typeArguments" in type && Array.isArray(type.typeArguments) && type.typeArguments?.length) {
+    return type.typeArguments[0];
+  }
+  if ("modifiersType" in type && type.modifiersType) {
+    return type.modifiersType;
+  }
+  return void 0;
+};
+
 const isClassDeclaration = (node) => {
   return node.kind === SYNTAX_KIND.CLASS_DECLARATION;
 };
@@ -169,13 +209,6 @@ const isConstructorDeclaration = (node) => {
   return node.kind === SYNTAX_KIND.CONSTRUCTOR;
 };
 
-const getSymbol = (type) => {
-  return type.getSymbol?.() ?? type.symbol;
-};
-const isClassType = (type) => {
-  return getSymbol(type)?.flags === SYMBOL_FLAGS.CLASS;
-};
-
 const isResourceWithReadonlyInterface = (type) => {
   if (!isResourceType(type) || !type.symbol?.name) return false;
   if (isIgnoreClass(type.symbol.name)) return false;
@@ -267,17 +300,45 @@ const noConstructInInterface = createRule({
             continue;
           }
           const type = parserServices.getTypeAtLocation(property);
-          if (!isClassType(type) || !isResourceWithReadonlyInterface(type)) {
+          if (isClassType(type) && isResourceWithReadonlyInterface(type)) {
+            context.report({
+              node: property,
+              messageId: "invalidInterfaceProperty",
+              data: {
+                propertyName: property.key.name,
+                typeName: type.symbol.name
+              }
+            });
             continue;
           }
-          context.report({
-            node: property,
-            messageId: "invalidInterfaceProperty",
-            data: {
-              propertyName: property.key.name,
-              typeName: type.symbol.name
-            }
-          });
+          const elementType = getArrayElementType(type);
+          if (elementType && isClassType(elementType) && isResourceWithReadonlyInterface(elementType)) {
+            context.report({
+              node: property,
+              messageId: "invalidInterfaceProperty",
+              data: {
+                propertyName: property.key.name,
+                typeName: `${elementType.symbol.name}[]`
+              }
+            });
+            continue;
+          }
+          const genericArgument = getGenericTypeArgument(type);
+          if (genericArgument && isClassType(genericArgument) && isResourceWithReadonlyInterface(genericArgument)) {
+            const wrapperName = (() => {
+              if (type.aliasSymbol) return type.aliasSymbol.name;
+              if (type.symbol?.name) return type.symbol.name;
+              return void 0;
+            })();
+            context.report({
+              node: property,
+              messageId: "invalidInterfaceProperty",
+              data: {
+                propertyName: property.key.name,
+                typeName: wrapperName ? `${wrapperName}<${genericArgument.symbol.name}>` : genericArgument.symbol.name
+              }
+            });
+          }
         }
       }
     };
@@ -327,15 +388,7 @@ const validatePublicPropertyOfConstruct = (node, context, parserServices) => {
     }
     if (!property.typeAnnotation) continue;
     const type = parserServices.getTypeAtLocation(property);
-    if (!isClassType(type) || !isResourceWithReadonlyInterface(type)) continue;
-    context.report({
-      node: property,
-      messageId: "invalidPublicPropertyOfConstruct",
-      data: {
-        propertyName: property.key.name,
-        typeName: type.symbol.name
-      }
-    });
+    checkAndReportConstructType(type, property, property.key.name, context);
   }
 };
 const validateConstructorParameterProperty = (constructor, context, parserServices) => {
@@ -348,15 +401,50 @@ const validateConstructorParameterProperty = (constructor, context, parserServic
     }
     if (!param.parameter.typeAnnotation) continue;
     const type = parserServices.getTypeAtLocation(param);
-    if (!isClassType(type) || !isResourceWithReadonlyInterface(type)) continue;
+    checkAndReportConstructType(type, param, param.parameter.name, context);
+  }
+};
+const checkAndReportConstructType = (type, node, propertyName, context) => {
+  if (isClassType(type) && isResourceWithReadonlyInterface(type)) {
     context.report({
-      node: param,
+      node,
       messageId: "invalidPublicPropertyOfConstruct",
       data: {
-        propertyName: param.parameter.name,
+        propertyName,
         typeName: type.symbol.name
       }
     });
+    return;
+  }
+  const elementType = getArrayElementType(type);
+  if (elementType && isClassType(elementType) && isResourceWithReadonlyInterface(elementType)) {
+    context.report({
+      node,
+      messageId: "invalidPublicPropertyOfConstruct",
+      data: {
+        propertyName,
+        typeName: `${elementType.symbol.name}[]`
+      }
+    });
+    return;
+  }
+  const genericArgument = getGenericTypeArgument(type);
+  if (genericArgument && isClassType(genericArgument) && isResourceWithReadonlyInterface(genericArgument)) {
+    const wrapperName = (() => {
+      if ("aliasSymbol" in type && type.aliasSymbol) {
+        return type.aliasSymbol.name;
+      }
+      if (type.symbol?.name) return type.symbol.name;
+      return void 0;
+    })();
+    context.report({
+      node,
+      messageId: "invalidPublicPropertyOfConstruct",
+      data: {
+        propertyName,
+        typeName: wrapperName ? `${wrapperName}<${genericArgument.symbol.name}>` : genericArgument.symbol.name
+      }
+    });
   }
 };
 
@@ -390,6 +478,9 @@ const SUFFIX_TYPE = {
   CONSTRUCT: "Construct",
   STACK: "Stack"
 };
+const defaultOption$2 = {
+  disallowedSuffixes: [SUFFIX_TYPE.CONSTRUCT, SUFFIX_TYPE.STACK]
+};
 const noConstructStackSuffix = createRule({
   name: "no-construct-stack-suffix",
   meta: {
@@ -417,16 +508,9 @@ const noConstructStackSuffix = createRule({
       }
     ]
   },
-  defaultOptions: [
-    {
-      disallowedSuffixes: [SUFFIX_TYPE.CONSTRUCT, SUFFIX_TYPE.STACK]
-    }
-  ],
+  defaultOptions: [defaultOption$2],
   create(context) {
     const parserServices = utils.ESLintUtils.getParserServices(context);
-    const options = context.options[0] ?? {
-      disallowedSuffixes: [SUFFIX_TYPE.CONSTRUCT, SUFFIX_TYPE.STACK]
-    };
     return {
       NewExpression(node) {
         const type = parserServices.getTypeAtLocation(node);
@@ -435,19 +519,20 @@ const noConstructStackSuffix = createRule({
         }
         const constructorPropertyNames = getConstructorPropertyNames(type);
         if (constructorPropertyNames[1] !== "id") return;
-        validateConstructId$3(node, context, options);
+        validateConstructId$3(node, context);
       }
     };
   }
 });
-const validateConstructId$3 = (node, context, options) => {
+const validateConstructId$3 = (node, context) => {
+  const options = context.options[0] ?? defaultOption$2;
   const secondArg = node.arguments[1];
   if (secondArg.type !== utils.AST_NODE_TYPES.Literal || typeof secondArg.value !== "string") {
     return;
   }
   const formattedConstructId = toPascalCase(secondArg.value);
   const disallowedSuffixes = options.disallowedSuffixes;
-  if (disallowedSuffixes.includes(SUFFIX_TYPE.CONSTRUCT) && formattedConstructId.endsWith(SUFFIX_TYPE.CONSTRUCT)) {
+  if (disallowedSuffixes?.includes(SUFFIX_TYPE.CONSTRUCT) && formattedConstructId.endsWith(SUFFIX_TYPE.CONSTRUCT)) {
     context.report({
       node: secondArg,
       messageId: "invalidConstructId",
@@ -457,7 +542,7 @@ const validateConstructId$3 = (node, context, options) => {
         suffix: SUFFIX_TYPE.CONSTRUCT
       }
     });
-  } else if (disallowedSuffixes.includes(SUFFIX_TYPE.STACK) && formattedConstructId.endsWith(SUFFIX_TYPE.STACK)) {
+  } else if (disallowedSuffixes?.includes(SUFFIX_TYPE.STACK) && formattedConstructId.endsWith(SUFFIX_TYPE.STACK)) {
     context.report({
       node: secondArg,
       messageId: "invalidConstructId",
@@ -600,6 +685,9 @@ const noMutablePublicPropertyOfConstruct = createRule({
   }
 });
 
+const defaultOption$1 = {
+  disallowContainingParentName: false
+};
 const noParentNameConstructIdMatch = createRule({
   name: "no-parent-name-construct-id-match",
   meta: {
@@ -623,15 +711,9 @@ const noParentNameConstructIdMatch = createRule({
       }
     ]
   },
-  defaultOptions: [
-    {
-      disallowContainingParentName: false
-    }
-  ],
+  defaultOptions: [defaultOption$1],
   create(context) {
-    const option = context.options[0] || {
-      disallowContainingParentName: false
-    };
+    const option = context.options[0] || defaultOption$1;
     const parserServices = utils.ESLintUtils.getParserServices(context);
     return {
       ClassBody(node) {
@@ -1290,6 +1372,9 @@ const requireJSDoc = createRule({
   }
 });
 
+const defaultOption = {
+  allowNonThisAndDisallowScope: true
+};
 const requirePassingThis = createRule({
   name: "require-passing-this",
   meta: {
@@ -1314,15 +1399,9 @@ const requirePassingThis = createRule({
     ],
     fixable: "code"
   },
-  defaultOptions: [
-    {
-      allowNonThisAndDisallowScope: false
-    }
-  ],
+  defaultOptions: [defaultOption],
   create(context) {
-    const options = context.options[0] || {
-      allowNonThisAndDisallowScope: false
-    };
+    const options = context.options[0] || defaultOption;
     const parserServices = utils.ESLintUtils.getParserServices(context);
     return {
       NewExpression(node) {

package/dist/index.d.ts

@@ -4,22 +4,22 @@ declare const rules: {
     "no-construct-in-interface": import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidInterfaceProperty", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     "no-construct-in-public-property-of-construct": import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidPublicPropertyOfConstruct", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     "no-construct-stack-suffix": import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidConstructId", [{
-        disallowedSuffixes: ("Construct" | "Stack")[];
+        disallowedSuffixes?: ("Construct" | "Stack")[];
     }], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     "no-import-private": import("eslint").Rule.RuleModule;
     "no-mutable-property-of-props-interface": import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidPropertyOfPropsInterface", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     "no-mutable-public-property-of-construct": import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidPublicPropertyOfConstruct", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
-    "no-parent-name-construct-id-match": import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidConstructId", [{
+    "no-parent-name-construct-id-match": import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidConstructId", {
         disallowContainingParentName?: boolean;
-    }], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    }[], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     "no-unused-props": import("@typescript-eslint/utils/ts-eslint").RuleModule<"unusedProp", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     "no-variable-construct-id": import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidConstructId", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     "pascal-case-construct-id": import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidConstructId", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     "props-name-convention": import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidPropsName", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     "require-jsdoc": import("@typescript-eslint/utils/ts-eslint").RuleModule<"missingJSDoc", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
-    "require-passing-this": import("@typescript-eslint/utils/ts-eslint").RuleModule<"missingPassingThis", [{
+    "require-passing-this": import("@typescript-eslint/utils/ts-eslint").RuleModule<"missingPassingThis", {
         allowNonThisAndDisallowScope?: boolean;
-    }], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    }[], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     "require-props-default-doc": import("@typescript-eslint/utils/ts-eslint").RuleModule<"missingDefaultDoc", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
 };
 declare const configs: {

package/dist/index.mjs

@@ -3,7 +3,7 @@ import { ESLintUtils, AST_NODE_TYPES, AST_TOKEN_TYPES } from '@typescript-eslint
 import * as path from 'path';
 
 var name = "eslint-cdk-plugin";
-var version = "3.4.0";
+var version = "3.4.2";
 
 const createRule = ESLintUtils.RuleCreator(
   (name) => `https://eslint-cdk-plugin.dev/rules/${name}`
@@ -130,6 +130,46 @@ const SYNTAX_KIND = {
   PROPERTY_ACCESS_EXPRESSION: 211
 };
 
+const getSymbol = (type) => {
+  return type.getSymbol?.() ?? type.symbol;
+};
+const isClassType = (type) => {
+  return getSymbol(type)?.flags === SYMBOL_FLAGS.CLASS;
+};
+const isArrayType = (type) => {
+  const symbol = getSymbol(type);
+  if (symbol?.name === "Array") return true;
+  if ("target" in type && type.target) {
+    const targetSymbol = getSymbol(type.target);
+    return targetSymbol?.name === "Array";
+  }
+  return false;
+};
+
+const getArrayElementType = (type) => {
+  if (!isArrayType(type)) return void 0;
+  if ("typeArguments" in type && Array.isArray(type.typeArguments)) {
+    return type.typeArguments[0];
+  }
+  return void 0;
+};
+
+const getGenericTypeArgument = (type) => {
+  if ("aliasSymbol" in type && type.aliasSymbol && "aliasTypeArguments" in type && type.aliasTypeArguments?.length) {
+    return type.aliasTypeArguments[0];
+  }
+  if ("typeArguments" in type && Array.isArray(type.typeArguments) && type.typeArguments?.length) {
+    return type.typeArguments[0];
+  }
+  if ("target" in type && type.target && "typeArguments" in type && Array.isArray(type.typeArguments) && type.typeArguments?.length) {
+    return type.typeArguments[0];
+  }
+  if ("modifiersType" in type && type.modifiersType) {
+    return type.modifiersType;
+  }
+  return void 0;
+};
+
 const isClassDeclaration = (node) => {
   return node.kind === SYNTAX_KIND.CLASS_DECLARATION;
 };
@@ -146,13 +186,6 @@ const isConstructorDeclaration = (node) => {
   return node.kind === SYNTAX_KIND.CONSTRUCTOR;
 };
 
-const getSymbol = (type) => {
-  return type.getSymbol?.() ?? type.symbol;
-};
-const isClassType = (type) => {
-  return getSymbol(type)?.flags === SYMBOL_FLAGS.CLASS;
-};
-
 const isResourceWithReadonlyInterface = (type) => {
   if (!isResourceType(type) || !type.symbol?.name) return false;
   if (isIgnoreClass(type.symbol.name)) return false;
@@ -244,17 +277,45 @@ const noConstructInInterface = createRule({
             continue;
           }
           const type = parserServices.getTypeAtLocation(property);
-          if (!isClassType(type) || !isResourceWithReadonlyInterface(type)) {
+          if (isClassType(type) && isResourceWithReadonlyInterface(type)) {
+            context.report({
+              node: property,
+              messageId: "invalidInterfaceProperty",
+              data: {
+                propertyName: property.key.name,
+                typeName: type.symbol.name
+              }
+            });
             continue;
           }
-          context.report({
-            node: property,
-            messageId: "invalidInterfaceProperty",
-            data: {
-              propertyName: property.key.name,
-              typeName: type.symbol.name
-            }
-          });
+          const elementType = getArrayElementType(type);
+          if (elementType && isClassType(elementType) && isResourceWithReadonlyInterface(elementType)) {
+            context.report({
+              node: property,
+              messageId: "invalidInterfaceProperty",
+              data: {
+                propertyName: property.key.name,
+                typeName: `${elementType.symbol.name}[]`
+              }
+            });
+            continue;
+          }
+          const genericArgument = getGenericTypeArgument(type);
+          if (genericArgument && isClassType(genericArgument) && isResourceWithReadonlyInterface(genericArgument)) {
+            const wrapperName = (() => {
+              if (type.aliasSymbol) return type.aliasSymbol.name;
+              if (type.symbol?.name) return type.symbol.name;
+              return void 0;
+            })();
+            context.report({
+              node: property,
+              messageId: "invalidInterfaceProperty",
+              data: {
+                propertyName: property.key.name,
+                typeName: wrapperName ? `${wrapperName}<${genericArgument.symbol.name}>` : genericArgument.symbol.name
+              }
+            });
+          }
         }
       }
     };
@@ -304,15 +365,7 @@ const validatePublicPropertyOfConstruct = (node, context, parserServices) => {
     }
     if (!property.typeAnnotation) continue;
     const type = parserServices.getTypeAtLocation(property);
-    if (!isClassType(type) || !isResourceWithReadonlyInterface(type)) continue;
-    context.report({
-      node: property,
-      messageId: "invalidPublicPropertyOfConstruct",
-      data: {
-        propertyName: property.key.name,
-        typeName: type.symbol.name
-      }
-    });
+    checkAndReportConstructType(type, property, property.key.name, context);
   }
 };
 const validateConstructorParameterProperty = (constructor, context, parserServices) => {
@@ -325,15 +378,50 @@ const validateConstructorParameterProperty = (constructor, context, parserServic
     }
     if (!param.parameter.typeAnnotation) continue;
     const type = parserServices.getTypeAtLocation(param);
-    if (!isClassType(type) || !isResourceWithReadonlyInterface(type)) continue;
+    checkAndReportConstructType(type, param, param.parameter.name, context);
+  }
+};
+const checkAndReportConstructType = (type, node, propertyName, context) => {
+  if (isClassType(type) && isResourceWithReadonlyInterface(type)) {
     context.report({
-      node: param,
+      node,
       messageId: "invalidPublicPropertyOfConstruct",
       data: {
-        propertyName: param.parameter.name,
+        propertyName,
         typeName: type.symbol.name
       }
     });
+    return;
+  }
+  const elementType = getArrayElementType(type);
+  if (elementType && isClassType(elementType) && isResourceWithReadonlyInterface(elementType)) {
+    context.report({
+      node,
+      messageId: "invalidPublicPropertyOfConstruct",
+      data: {
+        propertyName,
+        typeName: `${elementType.symbol.name}[]`
+      }
+    });
+    return;
+  }
+  const genericArgument = getGenericTypeArgument(type);
+  if (genericArgument && isClassType(genericArgument) && isResourceWithReadonlyInterface(genericArgument)) {
+    const wrapperName = (() => {
+      if ("aliasSymbol" in type && type.aliasSymbol) {
+        return type.aliasSymbol.name;
+      }
+      if (type.symbol?.name) return type.symbol.name;
+      return void 0;
+    })();
+    context.report({
+      node,
+      messageId: "invalidPublicPropertyOfConstruct",
+      data: {
+        propertyName,
+        typeName: wrapperName ? `${wrapperName}<${genericArgument.symbol.name}>` : genericArgument.symbol.name
+      }
+    });
   }
 };
 
@@ -367,6 +455,9 @@ const SUFFIX_TYPE = {
   CONSTRUCT: "Construct",
   STACK: "Stack"
 };
+const defaultOption$2 = {
+  disallowedSuffixes: [SUFFIX_TYPE.CONSTRUCT, SUFFIX_TYPE.STACK]
+};
 const noConstructStackSuffix = createRule({
   name: "no-construct-stack-suffix",
   meta: {
@@ -394,16 +485,9 @@ const noConstructStackSuffix = createRule({
       }
     ]
   },
-  defaultOptions: [
-    {
-      disallowedSuffixes: [SUFFIX_TYPE.CONSTRUCT, SUFFIX_TYPE.STACK]
-    }
-  ],
+  defaultOptions: [defaultOption$2],
   create(context) {
     const parserServices = ESLintUtils.getParserServices(context);
-    const options = context.options[0] ?? {
-      disallowedSuffixes: [SUFFIX_TYPE.CONSTRUCT, SUFFIX_TYPE.STACK]
-    };
     return {
       NewExpression(node) {
         const type = parserServices.getTypeAtLocation(node);
@@ -412,19 +496,20 @@ const noConstructStackSuffix = createRule({
         }
         const constructorPropertyNames = getConstructorPropertyNames(type);
         if (constructorPropertyNames[1] !== "id") return;
-        validateConstructId$3(node, context, options);
+        validateConstructId$3(node, context);
       }
     };
   }
 });
-const validateConstructId$3 = (node, context, options) => {
+const validateConstructId$3 = (node, context) => {
+  const options = context.options[0] ?? defaultOption$2;
   const secondArg = node.arguments[1];
   if (secondArg.type !== AST_NODE_TYPES.Literal || typeof secondArg.value !== "string") {
     return;
   }
   const formattedConstructId = toPascalCase(secondArg.value);
   const disallowedSuffixes = options.disallowedSuffixes;
-  if (disallowedSuffixes.includes(SUFFIX_TYPE.CONSTRUCT) && formattedConstructId.endsWith(SUFFIX_TYPE.CONSTRUCT)) {
+  if (disallowedSuffixes?.includes(SUFFIX_TYPE.CONSTRUCT) && formattedConstructId.endsWith(SUFFIX_TYPE.CONSTRUCT)) {
     context.report({
       node: secondArg,
       messageId: "invalidConstructId",
@@ -434,7 +519,7 @@ const validateConstructId$3 = (node, context, options) => {
         suffix: SUFFIX_TYPE.CONSTRUCT
       }
     });
-  } else if (disallowedSuffixes.includes(SUFFIX_TYPE.STACK) && formattedConstructId.endsWith(SUFFIX_TYPE.STACK)) {
+  } else if (disallowedSuffixes?.includes(SUFFIX_TYPE.STACK) && formattedConstructId.endsWith(SUFFIX_TYPE.STACK)) {
     context.report({
       node: secondArg,
       messageId: "invalidConstructId",
@@ -577,6 +662,9 @@ const noMutablePublicPropertyOfConstruct = createRule({
   }
 });
 
+const defaultOption$1 = {
+  disallowContainingParentName: false
+};
 const noParentNameConstructIdMatch = createRule({
   name: "no-parent-name-construct-id-match",
   meta: {
@@ -600,15 +688,9 @@ const noParentNameConstructIdMatch = createRule({
       }
     ]
   },
-  defaultOptions: [
-    {
-      disallowContainingParentName: false
-    }
-  ],
+  defaultOptions: [defaultOption$1],
   create(context) {
-    const option = context.options[0] || {
-      disallowContainingParentName: false
-    };
+    const option = context.options[0] || defaultOption$1;
     const parserServices = ESLintUtils.getParserServices(context);
     return {
       ClassBody(node) {
@@ -1267,6 +1349,9 @@ const requireJSDoc = createRule({
   }
 });
 
+const defaultOption = {
+  allowNonThisAndDisallowScope: true
+};
 const requirePassingThis = createRule({
   name: "require-passing-this",
   meta: {
@@ -1291,15 +1376,9 @@ const requirePassingThis = createRule({
     ],
     fixable: "code"
   },
-  defaultOptions: [
-    {
-      allowNonThisAndDisallowScope: false
-    }
-  ],
+  defaultOptions: [defaultOption],
   create(context) {
-    const options = context.options[0] || {
-      allowNonThisAndDisallowScope: false
-    };
+    const options = context.options[0] || defaultOption;
     const parserServices = ESLintUtils.getParserServices(context);
     return {
       NewExpression(node) {