refactor: improve ngWalker by preventing an error when a class has no name

src/angular/metadata.ts

@@ -44,3 +44,20 @@ export class ComponentMetadata extends DirectiveMetadata {
     super(controller, decorator, selector);
   }
 }
+
+export class PipeMetadata {
+  constructor(
+    public readonly controller: ts.ClassDeclaration,
+    public readonly decorator: ts.Decorator,
+    public readonly name?: string,
+    public readonly pure?: string
+  ) {}
+}
+
+export class ModuleMetadata {
+  constructor(public readonly controller: ts.ClassDeclaration, public readonly decorator: ts.Decorator) {}
+}
+
+export class InjectableMetadata {
+  constructor(public readonly controller: ts.ClassDeclaration, public readonly decorator: ts.Decorator) {}
+}

src/angular/metadataReader.ts

@@ -1,12 +1,22 @@
 import * as ts from 'typescript';
-import { callExpression, decoratorArgument, hasProperties, withIdentifier } from '../util/astQuery';
+import { callExpression, decoratorArgument, getStringInitializerFromProperty, hasProperties, withIdentifier } from '../util/astQuery';
 import { ifTrue, listToMaybe, Maybe, unwrapFirst } from '../util/function';
 import { logger } from '../util/logger';
 import { getAnimations, getInlineStyle, getTemplate } from '../util/ngQuery';
 import { getDecoratorPropertyInitializer, isStringLiteralLike, maybeNodeArray } from '../util/utils';
 import { Config } from './config';
 import { FileResolver } from './fileResolver/fileResolver';
-import { AnimationMetadata, CodeWithSourceMap, ComponentMetadata, DirectiveMetadata, StyleMetadata, TemplateMetadata } from './metadata';
+import {
+  AnimationMetadata,
+  CodeWithSourceMap,
+  ComponentMetadata,
+  DirectiveMetadata,
+  InjectableMetadata,
+  ModuleMetadata,
+  PipeMetadata,
+  StyleMetadata,
+  TemplateMetadata
+} from './metadata';
 import { AbstractResolver, MetadataUrls } from './urlResolvers/abstractResolver';
 import { PathResolver } from './urlResolvers/pathResolver';
 import { UrlResolver } from './urlResolvers/urlResolver';
@@ -26,7 +36,7 @@ export class MetadataReader {
     this.urlResolver = this.urlResolver || new UrlResolver(new PathResolver());
   }
 
-  read(d: ts.ClassDeclaration): DirectiveMetadata | undefined {
+  read(d: ts.ClassDeclaration): DirectiveMetadata | ComponentMetadata | PipeMetadata | ModuleMetadata | InjectableMetadata | undefined {
     const componentMetadata = unwrapFirst<ComponentMetadata | undefined>(
       maybeNodeArray(d.decorators!).map(dec => {
         return Maybe.lift(dec)
@@ -45,7 +55,34 @@ export class MetadataReader {
       )
     );
 
-    return directiveMetadata || componentMetadata || undefined;
+    const pipeMetadata = unwrapFirst<PipeMetadata | undefined>(
+      maybeNodeArray(d.decorators!).map(dec =>
+        Maybe.lift(dec)
+          .bind(callExpression)
+          .bind(withIdentifier('Pipe') as any)
+          .fmap(() => this.readPipeMetadata(d, dec))
+      )
+    );
+
+    const moduleMetadata = unwrapFirst<ModuleMetadata | undefined>(
+      maybeNodeArray(d.decorators!).map(dec =>
+        Maybe.lift(dec)
+          .bind(callExpression)
+          .bind(withIdentifier('NgModule') as any)
+          .fmap(() => this.readModuleMetadata(d, dec))
+      )
+    );
+
+    const injectableMetadata = unwrapFirst<InjectableMetadata | undefined>(
+      maybeNodeArray(d.decorators!).map(dec =>
+        Maybe.lift(dec)
+          .bind(callExpression)
+          .bind(withIdentifier('Injectable') as any)
+          .fmap(() => this.readInjectableMetadata(d, dec))
+      )
+    );
+
+    return directiveMetadata || componentMetadata || pipeMetadata || moduleMetadata || injectableMetadata || undefined;
   }
 
   protected readDirectiveMetadata(d: ts.ClassDeclaration, dec: ts.Decorator): DirectiveMetadata {
@@ -55,6 +92,26 @@ export class MetadataReader {
     return new DirectiveMetadata(d, dec, selector);
   }
 
+  protected readPipeMetadata(d: ts.ClassDeclaration, dec: ts.Decorator): DirectiveMetadata {
+    const name = this.getDecoratorArgument(dec)
+      .bind(expr => getStringInitializerFromProperty('name', expr!.properties))
+      .fmap(initializer => initializer!.text);
+
+    const pure = this.getDecoratorArgument(dec)
+      .bind(expr => getStringInitializerFromProperty('pure', expr!.properties))
+      .fmap(initializer => initializer!.text);
+
+    return new PipeMetadata(d, dec, name.unwrap(), pure ? pure.unwrap() : undefined);
+  }
+
+  protected readModuleMetadata(d: ts.ClassDeclaration, dec: ts.Decorator): DirectiveMetadata {
+    return new ModuleMetadata(d, dec);
+  }
+
+  protected readInjectableMetadata(d: ts.ClassDeclaration, dec: ts.Decorator): DirectiveMetadata {
+    return new InjectableMetadata(d, dec);
+  }
+
   protected readComponentMetadata(d: ts.ClassDeclaration, dec: ts.Decorator): ComponentMetadata {
     const expr = this.getDecoratorArgument(dec);
     const directiveMetadata = this.readDirectiveMetadata(d, dec);

src/angular/ngWalker.ts

@@ -2,9 +2,9 @@ import * as compiler from '@angular/compiler';
 import * as Lint from 'tslint';
 import * as ts from 'typescript';
 import { logger } from '../util/logger';
-import { getDecoratorName, maybeNodeArray } from '../util/utils';
+import { getClassName, getDecoratorName, maybeNodeArray } from '../util/utils';
 import { Config } from './config';
-import { ComponentMetadata, DirectiveMetadata, StyleMetadata } from './metadata';
+import { ComponentMetadata, DirectiveMetadata, InjectableMetadata, ModuleMetadata, PipeMetadata, StyleMetadata } from './metadata';
 import { MetadataReader } from './metadataReader';
 import { ngWalkerFactoryUtils } from './ngWalkerFactoryUtils';
 import { BasicCssAstVisitor, CssAstVisitorCtrl } from './styles/basicCssAstVisitor';
@@ -61,11 +61,19 @@ export class NgWalker extends Lint.RuleWalker {
   }
 
   visitClassDeclaration(declaration: ts.ClassDeclaration) {
-    const metadata = this._metadataReader!.read(declaration);
-    if (metadata instanceof ComponentMetadata) {
-      this.visitNgComponent(metadata);
-    } else if (metadata instanceof DirectiveMetadata) {
-      this.visitNgDirective(metadata);
+    if (this.hasClassName(declaration)) {
+      const metadata = this._metadataReader!.read(declaration);
+      if (metadata instanceof ComponentMetadata) {
+        this.visitNgComponent(metadata);
+      } else if (metadata instanceof DirectiveMetadata) {
+        this.visitNgDirective(metadata);
+      } else if (metadata instanceof PipeMetadata) {
+        this.visitNgPipe(metadata);
+      } else if (metadata instanceof ModuleMetadata) {
+        this.visitNgModule(metadata);
+      } else if (metadata instanceof InjectableMetadata) {
+        this.visitNgInjectable(metadata);
+      }
     }
     maybeNodeArray(ts.createNodeArray(declaration.decorators)).forEach(this.visitClassDecorator.bind(this));
     super.visitClassDeclaration(declaration);
@@ -115,22 +123,6 @@ export class NgWalker extends Lint.RuleWalker {
     }
   }
 
-  protected visitClassDecorator(decorator: ts.Decorator) {
-    let name = getDecoratorName(decorator);
-
-    if (name === 'Injectable') {
-      this.visitNgInjectable(decorator.parent as ts.ClassDeclaration, decorator);
-    }
-
-    if (name === 'Pipe') {
-      this.visitNgPipe(decorator.parent as ts.ClassDeclaration, decorator);
-    }
-
-    if (name === 'NgModule') {
-      this.visitNgModule(decorator);
-    }
-  }
-
   protected visitNgComponent(metadata: ComponentMetadata) {
     const { styles = [] } = metadata;
 
@@ -165,13 +157,15 @@ export class NgWalker extends Lint.RuleWalker {
     }
   }
 
-  protected visitNgModule(decorator: ts.Decorator) {}
+  protected visitClassDecorator(decorator: ts.Decorator) {}
+
+  protected visitNgModule(metadata: ModuleMetadata) {}
 
   protected visitNgDirective(metadata: DirectiveMetadata) {}
 
-  protected visitNgPipe(controller: ts.ClassDeclaration, decorator: ts.Decorator) {}
+  protected visitNgPipe(metadata: DirectiveMetadata) {}
 
-  protected visitNgInjectable(classDeclaration: ts.ClassDeclaration, decorator: ts.Decorator) {}
+  protected visitNgInjectable(metadata: InjectableMetadata) {}
 
   protected visitNgInput(property: ts.PropertyDeclaration, input: ts.Decorator, args: string[]) {}
 
@@ -237,4 +231,13 @@ export class NgWalker extends Lint.RuleWalker {
 
     return sf;
   }
+
+  private hasClassName(node: ts.Decorator | ts.ClassDeclaration) {
+    if (ts.isDecorator(node) && !getClassName(node.parent as ts.ClassDeclaration)) {
+      return false;
+    } else if (ts.isClassDeclaration(node) && !getClassName(node)) {
+      return false;
+    }
+    return true;
+  }
 }

src/contextualLifecycleRule.ts

@@ -14,6 +14,7 @@ import {
   MetadataTypeKeys,
   MetadataTypes
 } from './util/utils';
+import { InjectableMetadata, PipeMetadata } from './angular';
 
 interface FailureParameters {
   readonly className: string;
@@ -45,20 +46,18 @@ export class Rule extends AbstractRule {
 }
 
 class ContextualLifecycleWalker extends NgWalker {
-  protected visitNgInjectable(controller: ClassDeclaration, decorator: Decorator): void {
-    this.validateDecorator(controller, decorator, METADATA_TYPE_LIFECYCLE_MAPPER.Injectable);
-    super.visitNgInjectable(controller, decorator);
+  visitNgInjectable(metadata: InjectableMetadata): void {
+    this.validateDecorator(metadata.controller, metadata.decorator, METADATA_TYPE_LIFECYCLE_MAPPER.Injectable);
+    super.visitNgInjectable(metadata);
   }
 
-  protected visitNgPipe(controller: ClassDeclaration, decorator: Decorator): void {
-    this.validateDecorator(controller, decorator, METADATA_TYPE_LIFECYCLE_MAPPER.Pipe);
-    super.visitNgPipe(controller, decorator);
+  visitNgPipe(metadata: PipeMetadata): void {
+    this.validateDecorator(metadata.controller, metadata.decorator, METADATA_TYPE_LIFECYCLE_MAPPER.Pipe);
+    super.visitNgPipe(metadata);
   }
 
   private validateDecorator(controller: ClassDeclaration, decorator: Decorator, allowedMethods: ReadonlySet<LifecycleMethodKeys>): void {
-    const className = getClassName(controller);
-
-    if (!className) return;
+    const className = getClassName(controller)!;
 
     const metadataType = getDecoratorName(decorator);
 

src/noPipeImpureRule.ts

@@ -4,6 +4,7 @@ import { AbstractRule } from 'tslint/lib/rules';
 import { ClassDeclaration, Decorator, SourceFile, SyntaxKind } from 'typescript';
 import { NgWalker } from './angular/ngWalker';
 import { getClassName, getDecoratorPropertyInitializer } from './util/utils';
+import { PipeMetadata } from './angular';
 
 interface FailureParameters {
   readonly className: string;
@@ -31,13 +32,13 @@ export class Rule extends AbstractRule {
 }
 
 export class ClassMetadataWalker extends NgWalker {
-  protected visitNgPipe(controller: ClassDeclaration, decorator: Decorator): void {
-    this.validatePipe(controller, decorator);
-    super.visitNgPipe(controller, decorator);
+  protected visitNgPipe(metadata: PipeMetadata): void {
+    this.validatePipe(metadata);
+    super.visitNgPipe(metadata);
   }
 
-  private validatePipe(controller: ClassDeclaration, decorator: Decorator): void {
-    const pureExpression = getDecoratorPropertyInitializer(decorator, 'pure');
+  private validatePipe(metadata: PipeMetadata): void {
+    const pureExpression = getDecoratorPropertyInitializer(metadata.decorator, 'pure');
 
     if (!pureExpression) return;
 
@@ -46,9 +47,7 @@ export class ClassMetadataWalker extends NgWalker {
 
     if (!parentExpression || isNotFalseLiteral) return;
 
-    const className = getClassName(controller);
-
-    if (!className) return;
+    const className = getClassName(metadata.controller)!;
 
     const failure = getFailureMessage({ className });
 

src/pipePrefixRule.ts

@@ -4,6 +4,7 @@ import * as ts from 'typescript';
 import { NgWalker } from './angular/ngWalker';
 import { SelectorValidator } from './util/selectorValidator';
 import { getDecoratorArgument } from './util/utils';
+import { PipeMetadata } from './angular';
 
 export class Rule extends Lint.Rules.AbstractRule {
   static readonly metadata: Lint.IRuleMetadata = {
@@ -69,10 +70,10 @@ export class ClassMetadataWalker extends NgWalker {
     super(sourceFile, rule.getOptions());
   }
 
-  protected visitNgPipe(controller: ts.ClassDeclaration, decorator: ts.Decorator) {
-    let className = controller.name!.text;
-    this.validateProperties(className, decorator);
-    super.visitNgPipe(controller, decorator);
+  protected visitNgPipe(metadata: PipeMetadata) {
+    let className = metadata.controller.name!.text;
+    this.validateProperties(className, metadata.decorator);
+    super.visitNgPipe(metadata);
   }
 
   private validateProperties(className: string, pipe: ts.Decorator) {