fix(awslint): include types from submodules during linting (WIP)

packages/awslint/lib/rules/cfn-resource.ts

@@ -37,7 +37,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));
   }

packages/awslint/lib/rules/construct.ts

@@ -2,14 +2,14 @@ import * as reflect from 'jsii-reflect';
 import { CoreTypes } from './core-types';
 import { Linter, MethodSignatureParameterExpectation } from '../linter';
 
-export const constructLinter = new Linter<ConstructReflection>(assembly => assembly.classes
+export const constructLinter = new Linter<ConstructReflection>(assembly => assembly.allClasses
   .filter(t => CoreTypes.isConstructClass(t))
   .map(construct => new ConstructReflection(construct)));
 
 export class ConstructReflection {
 
   public static findAllConstructs(assembly: reflect.Assembly) {
-    return assembly.classes
+    return assembly.allClasses
       .filter(c => CoreTypes.isConstructClass(c))
       .map(c => new ConstructReflection(c));
   }

packages/awslint/lib/rules/docs.ts

@@ -15,17 +15,17 @@ type DocsLinterContext = {
 
 export const docsLinter = new Linter<DocsLinterContext>(assembly => {
   return [
-    ...flatMap(assembly.classes, classType => [
+    ...flatMap(assembly.allClasses, classType => [
       { assembly, kind: 'type', documentable: classType, errorKey: classType.fqn },
       ...classType.ownProperties.map(property => ({ assembly, kind: 'class-property', containingType: classType, documentable: property, errorKey: `${classType.fqn}.${property.name}` })),
       ...classType.ownMethods.map(method => ({ assembly, kind: 'method', containingType: classType, documentable: method, errorKey: `${classType.fqn}.${method.name}` })),
     ]),
-    ...flatMap(assembly.interfaces, interfaceType => [
+    ...flatMap(assembly.allInterfaces, interfaceType => [
       { assembly, kind: 'type', documentable: interfaceType, errorKey: interfaceType.fqn },
       ...interfaceType.ownProperties.map(property => ({ assembly, kind: 'interface-property', containingType: interfaceType, documentable: property, errorKey: `${interfaceType.fqn}.${property.name}` })),
       ...interfaceType.ownMethods.map(method => ({ assembly, kind: 'method', containingType: interfaceType, documentable: method, errorKey: `${interfaceType.fqn}.${method.name}` })),
     ]),
-    ...flatMap(assembly.enums, enumType => [
+    ...flatMap(assembly.allEnums, enumType => [
       { assembly, kind: 'type', documentable: enumType, errorKey: enumType.fqn },
       ...enumType.members.map(member => ({ assembly, kind: 'enum-member', containingType: enumType, documentable: member, errorKey: `${enumType.fqn}.${member.name}` })),
     ]),
@@ -53,7 +53,9 @@ docsLinter.add({
     if (e.ctx.kind !== 'interface-property') { return; }
     if (!e.ctx.containingType.isDataType()) { return; }
     // this rule does not apply to L1 constructs
-    if (CoreTypes.isCfnType(e.ctx.containingType)) { return; }
+    if (CoreTypes.isCfnType(e.ctx.containingType)) {
+      return;
+    }
 
     const property = e.ctx.documentable;
     e.assert(!property.optional || property.docs.docs.default !== undefined, e.ctx.errorKey);

packages/awslint/lib/rules/integrations.ts

@@ -2,7 +2,7 @@ import * as reflect from 'jsii-reflect';
 import { memberFqn } from './util';
 import { Linter } from '../linter';
 
-export const integrationLinter = new Linter<IntegrationReflection>(assembly => assembly.interfaces
+export const integrationLinter = new Linter<IntegrationReflection>(assembly => assembly.allInterfaces
   .filter(IntegrationReflection.isIntegrationInterface)
   .map(construct => new IntegrationReflection(construct)));
 

packages/awslint/lib/rules/public-static-properties.ts

@@ -5,7 +5,7 @@ const UPPER_SNAKE_CASE_ALLOWED_PATTERN = new RegExp('^[A-Z0-9][A-Z0-9_]*[A-Z0-9]
 
 export const publicStaticPropertiesLinter = new Linter(assembly => {
   const result = new Array<Property>();
-  for (const c of assembly.classes) {
+  for (const c of assembly.allClasses) {
     for (const property of c.allProperties) {
       if (property.const && property.static) {
         result.push(property);