@@ -11,7 +11,7 @@ import * as ts from 'typescript';
1111import { materialModuleSpecifier } from '../../../ng-update/typescript/module-specifiers' ;
1212
1313/**
14- * Regex for testing file paths against to determinte if the file is from the
14+ * Regex for testing file paths against to determine if the file is from the
1515 * Angular Material library.
1616 */
1717const ANGULAR_MATERIAL_FILEPATH_REGEX = new RegExp ( `${ materialModuleSpecifier } ) ;
@@ -51,17 +51,20 @@ export class Rule extends Lint.Rules.TypedRule {
5151
5252/**
5353 * A walker to walk a given source file to check for imports from the
54- * @angular /material module.
54+ * " @angular/material" module.
5555 */
5656function walk ( ctx : Lint . WalkContext < boolean > , checker : ts . TypeChecker ) : void {
5757 // The source file to walk.
5858 const sf = ctx . sourceFile ;
59+ const printer = ts . createPrinter ( ) ;
5960 const cb = ( declaration : ts . Node ) => {
6061 // Only look at import declarations.
61- if ( ! ts . isImportDeclaration ( declaration ) ) {
62+ if ( ! ts . isImportDeclaration ( declaration ) ||
63+ ! ts . isStringLiteralLike ( declaration . moduleSpecifier ) ) {
6264 return ;
6365 }
64- const importLocation = declaration . moduleSpecifier . getText ( sf ) ;
66+
67+ const importLocation = declaration . moduleSpecifier . text ;
6568 // If the import module is not @angular /material, skip check.
6669 if ( importLocation !== materialModuleSpecifier ) {
6770 return ;
@@ -85,86 +88,95 @@ function walk(ctx: Lint.WalkContext<boolean>, checker: ts.TypeChecker): void {
8588 return ctx . addFailureAtNode ( declaration , Rule . NO_IMPORT_NAMED_SYMBOLS_FAILURE_STR ) ;
8689 }
8790
88- // Map of submodule locations to arrays of imported symbols.
89- const importMap = new Map < string , Set < string > > ( ) ;
91+ // Map which consists of secondary entry-points and import specifiers which are used
92+ // within the current import declaration.
93+ const importMap = new Map < string , ts . ImportSpecifier [ ] > ( ) ;
9094
9195 // Determine the subpackage each symbol in the namedBinding comes from.
9296 for ( const element of declaration . importClause . namedBindings . elements ) {
93- // Confirm the named import is a symbol that can be looked up .
97+ // Ensure the import specifier name is statically analyzable .
9498 if ( ! ts . isIdentifier ( element . name ) ) {
95- return ctx . addFailureAtNode (
96- element , element . getFullText ( sf ) + Rule . SYMBOL_NOT_FOUND_FAILURE_STR ) ;
99+ return ctx . addFailureAtNode ( element , element . getText ( ) + Rule . SYMBOL_NOT_FOUND_FAILURE_STR ) ;
97100 }
98- // Get the type for the named binding element.
99- const type = checker . getTypeAtLocation ( element . name ) ;
100- // Get the original symbol where it is declared upstream.
101- const symbol = type . getSymbol ( ) ;
101+
102+ // Get the symbol for the named binding element. Note that we cannot determine the
103+ // value declaration based on the type of the element as types are not necessarily
104+ // specific to a given secondary entry-point (e.g. exports with the type of "string")
105+ // would resolve to the module types provided by TypeScript itself.
106+ const symbol = getDeclarationSymbolOfNode ( element . name , checker ) ;
102107
103108 // If the symbol can't be found, add failure saying the symbol
104109 // can't be found.
105110 if ( ! symbol || ! symbol . valueDeclaration ) {
106- return ctx . addFailureAtNode (
107- element , element . getFullText ( sf ) + Rule . SYMBOL_NOT_FOUND_FAILURE_STR ) ;
108- }
109-
110- // If the symbol has no declarations, add failure saying the symbol can't
111- // be found.
112- if ( ! symbol . declarations || ! symbol . declarations . length ) {
113- return ctx . addFailureAtNode (
114- element , element . getFullText ( sf ) + Rule . SYMBOL_NOT_FOUND_FAILURE_STR ) ;
111+ return ctx . addFailureAtNode ( element , element . getText ( ) + Rule . SYMBOL_NOT_FOUND_FAILURE_STR ) ;
115112 }
116113
117114 // The filename for the source file of the node that contains the
118- // first declaration of the symbol. All symbol declarations must be
115+ // first declaration of the symbol. All symbol declarations must be
119116 // part of a defining node, so parent can be asserted to be defined.
120- const sourceFile = symbol . valueDeclaration . getSourceFile ( ) . fileName ;
117+ const sourceFile : string = symbol . valueDeclaration . getSourceFile ( ) . fileName ;
118+
121119 // File the module the symbol belongs to from a regex match of the
122- // filename. This will always match since only @angular /material symbols
123- // are being looked at .
124- const [ , moduleName ] = sourceFile . match ( ANGULAR_MATERIAL_FILEPATH_REGEX ) || [ ] as undefined [ ] ;
125- if ( ! moduleName ) {
120+ // filename. This will always match since only " @angular/material"
121+ // elements are analyzed .
122+ const matches = sourceFile . match ( ANGULAR_MATERIAL_FILEPATH_REGEX ) ;
123+ if ( ! matches ) {
126124 return ctx . addFailureAtNode (
127- element , element . getFullText ( sf ) + Rule . SYMBOL_FILE_NOT_FOUND_FAILURE_STR ) ;
125+ element , element . getText ( ) + Rule . SYMBOL_FILE_NOT_FOUND_FAILURE_STR ) ;
128126 }
129- // The module name where the symbol is defined e.g. card, dialog. The
127+ const [ , moduleName ] = matches ;
128+
129+ // The module name where the symbol is defined e.g. card, dialog. The
130130 // first capture group is contains the module name.
131131 if ( importMap . has ( moduleName ) ) {
132- importMap . get ( moduleName ) ! . add ( symbol . getName ( ) ) ;
132+ importMap . get ( moduleName ) ! . push ( element ) ;
133133 } else {
134- importMap . set ( moduleName , new Set ( [ symbol . getName ( ) ] ) ) ;
134+ importMap . set ( moduleName , [ element ] ) ;
135135 }
136136 }
137- const fix = buildSecondaryImportStatements ( importMap ) ;
138137
139- // Without a fix to provide, show error message only.
140- if ( ! fix ) {
138+ // Transforms the import declaration into multiple import declarations that import
139+ // the given symbols from the individual secondary entry-points. For example:
140+ // import {MatCardModule, MatCardTitle} from '@angular/material/card';
141+ // import {MatRadioModule} from '@angular/material/radio';
142+ const newImportStatements =
143+ Array . from ( importMap . entries ( ) )
144+ . sort ( )
145+ . map ( ( [ name , elements ] ) => {
146+ const newImport = ts . createImportDeclaration (
147+ undefined , undefined ,
148+ ts . createImportClause ( undefined , ts . createNamedImports ( elements ) ) ,
149+ ts . createStringLiteral ( `${ materialModuleSpecifier } ${ name } ) ) ;
150+ return printer . printNode ( ts . EmitHint . Unspecified , newImport , sf ) ;
151+ } )
152+ . join ( '\n' ) ;
153+
154+ // Without any import statements that were generated, we can assume that this was an empty
155+ // import declaration. We still want to add a failure in order to make developers aware that
156+ // importing from "@angular/material" is deprecated.
157+ if ( ! newImportStatements ) {
141158 return ctx . addFailureAtNode ( declaration . moduleSpecifier , Rule . ONLY_SUBPACKAGE_FAILURE_STR ) ;
142159 }
143- // Mark the lint failure at the module specifier, providing a
144- // recommended fix.
160+
161+ // Mark the lint failure at the module specifier, providing the replacement that switches
162+ // the import to individual secondary entry-point imports.
145163 ctx . addFailureAtNode (
146164 declaration . moduleSpecifier , Rule . ONLY_SUBPACKAGE_FAILURE_STR ,
147- new Lint . Replacement ( declaration . getStart ( sf ) , declaration . getWidth ( ) , fix ) ) ;
165+ new Lint . Replacement ( declaration . getStart ( ) , declaration . getWidth ( ) , newImportStatements ) ) ;
148166 } ;
167+
149168 sf . statements . forEach ( cb ) ;
150169}
151170
152- /**
153- * Builds the recommended fix from a map of the imported symbols found in the
154- * import declaration. Imports declarations are sorted by module, then by
155- * symbol within each import declaration.
156- *
157- * Example of the format:
158- *
159- * import {MatCardModule, MatCardTitle} from '@angular/material/card';
160- * import {MatRadioModule} from '@angular/material/radio';
161- */
162- function buildSecondaryImportStatements ( importMap : Map < string , Set < string > > ) : string {
163- return Array . from ( importMap . entries ( ) )
164- . sort ( ( a , b ) => a [ 0 ] > b [ 0 ] ? 1 : - 1 )
165- . map ( entry => {
166- const imports = Array . from ( entry [ 1 ] ) . sort ( ( a , b ) => a > b ? 1 : - 1 ) . join ( ', ' ) ;
167- return `import {${ imports } ${ entry [ 0 ] } ;
168- } )
169- . join ( '' ) ;
171+ /** Gets the symbol that contains the value declaration of the given node. */
172+ function getDeclarationSymbolOfNode ( node : ts . Node , checker : ts . TypeChecker ) {
173+ const symbol = checker . getSymbolAtLocation ( node ) ;
174+
175+ // Symbols can be aliases of the declaration symbol. e.g. in named import specifiers.
176+ // We need to resolve the aliased symbol back to the declaration symbol.
177+ // tslint:disable-next-line:no-bitwise
178+ if ( symbol && ( symbol . flags & ts . SymbolFlags . Alias ) !== 0 ) {
179+ return checker . getAliasedSymbol ( symbol ) ;
180+ }
181+ return symbol ;
170182}
0 commit comments