@@ -16,13 +16,143 @@ module.exports = {
1616 docs : {
1717 url : docsUrl ( 'no-namespace' ) ,
1818 } ,
19+ fixable : 'code' ,
1920 } ,
2021
2122 create : function ( context ) {
2223 return {
2324 'ImportNamespaceSpecifier' : function ( node ) {
24- context . report ( node , `Unexpected namespace import.` )
25+ const scopeVariables = context . getScope ( ) . variables
26+ const namespaceVariable = scopeVariables . find ( ( variable ) =>
27+ variable . defs [ 0 ] . node === node
28+ )
29+ const namespaceReferences = namespaceVariable . references
30+ const namespaceIdentifiers = namespaceReferences . map ( reference => reference . identifier )
31+ const canFix = namespaceIdentifiers . length > 0 && ! usesNamespaceAsObject ( namespaceIdentifiers )
32+
33+ context . report ( {
34+ node,
35+ message : `Unexpected namespace import.` ,
36+ fix : canFix && ( fixer => {
37+ const scopeManager = context . getSourceCode ( ) . scopeManager
38+ const fixes = [ ]
39+
40+ // Pass 1: Collect variable names that are already in scope for each reference we want
41+ // to transform, so that we can be sure that we choose non-conflicting import names
42+ const importNameConflicts = { }
43+ namespaceIdentifiers . forEach ( ( identifier ) => {
44+ const parent = identifier . parent
45+ if ( parent && parent . type === 'MemberExpression' ) {
46+ const importName = getMemberPropertyName ( parent )
47+ const localConflicts = getVariableNamesInScope ( scopeManager , parent )
48+ if ( ! importNameConflicts [ importName ] ) {
49+ importNameConflicts [ importName ] = localConflicts
50+ } else {
51+ localConflicts . forEach ( ( c ) => importNameConflicts [ importName ] . add ( c ) )
52+ }
53+ }
54+ } )
55+
56+ // Choose new names for each import
57+ const importNames = Object . keys ( importNameConflicts )
58+ const importLocalNames = generateLocalNames (
59+ importNames ,
60+ importNameConflicts ,
61+ namespaceVariable . name
62+ )
63+
64+ // Replace the ImportNamespaceSpecifier with a list of ImportSpecifiers
65+ const namedImportSpecifiers = importNames . map ( ( importName ) =>
66+ importName === importLocalNames [ importName ]
67+ ? importName
68+ : `${ importName } ${ importLocalNames [ importName ] }
69+ )
70+ fixes . push ( fixer . replaceText ( node , `{ ${ namedImportSpecifiers . join ( ', ' ) } ) )
71+
72+ // Pass 2: Replace references to the namespace with references to the named imports
73+ namespaceIdentifiers . forEach ( ( identifier ) => {
74+ const parent = identifier . parent
75+ if ( parent && parent . type === 'MemberExpression' ) {
76+ const importName = getMemberPropertyName ( parent )
77+ fixes . push ( fixer . replaceText ( parent , importLocalNames [ importName ] ) )
78+ }
79+ } )
80+
81+ return fixes
82+ } ) ,
83+ } )
2584 } ,
2685 }
2786 } ,
2887}
88+
89+ /**
90+ * @param {Identifier[] } namespaceIdentifiers
91+ * @returns {boolean } `true` if the namespace variable is more than just a glorified constant
92+ */
93+ function usesNamespaceAsObject ( namespaceIdentifiers ) {
94+ return ! namespaceIdentifiers . every ( ( identifier ) => {
95+ const parent = identifier . parent
96+
97+ // `namespace.x` or `namespace['x']`
98+ return (
99+ parent && parent . type === 'MemberExpression' &&
100+ ( parent . property . type === 'Identifier' || parent . property . type === 'Literal' )
101+ )
102+ } )
103+ }
104+
105+ /**
106+ * @param {MemberExpression } memberExpression
107+ * @returns {string } the name of the member in the object expression, e.g. the `x` in `namespace.x`
108+ */
109+ function getMemberPropertyName ( memberExpression ) {
110+ return memberExpression . property . type === 'Identifier'
111+ ? memberExpression . property . name
112+ : memberExpression . property . value
113+ }
114+
115+ /**
116+ * @param {ScopeManager } scopeManager
117+ * @param {ASTNode } node
118+ * @return {Set<string> }
119+ */
120+ function getVariableNamesInScope ( scopeManager , node ) {
121+ let currentNode = node
122+ let scope = scopeManager . acquire ( currentNode )
123+ while ( scope == null ) {
124+ currentNode = currentNode . parent
125+ scope = scopeManager . acquire ( currentNode , true )
126+ }
127+ return new Set ( [
128+ ...scope . variables . map ( variable => variable . name ) ,
129+ ...scope . upper . variables . map ( variable => variable . name ) ,
130+ ] )
131+ }
132+
133+ /**
134+ *
135+ * @param {* } names
136+ * @param {* } nameConflicts
137+ * @param {* } namespaceName
138+ */
139+ function generateLocalNames ( names , nameConflicts , namespaceName ) {
140+ const localNames = { }
141+ names . forEach ( ( name ) => {
142+ let localName
143+ if ( ! nameConflicts [ name ] . has ( name ) ) {
144+ localName = name
145+ } else if ( ! nameConflicts [ name ] . has ( `${ namespaceName } ${ name } ) ) {
146+ localName = `${ namespaceName } ${ name }
147+ } else {
148+ for ( let i = 1 ; i < Infinity ; i ++ ) {
149+ if ( ! nameConflicts [ name ] . has ( `${ namespaceName } ${ name } ${ i } ) ) {
150+ localName = `${ namespaceName } ${ name } ${ i }
151+ break
152+ }
153+ }
154+ }
155+ localNames [ name ] = localName
156+ } )
157+ return localNames
158+ }
0 commit comments