Fix: wrong decorator's location (fixes #21)

Author: mysticatea

package.json

@@ -17,6 +17,7 @@
   "dependencies": {
     "debug": "^3.1.0",
     "eslint-scope": "^3.7.1",
+    "eslint-visitor-keys": "^1.0.0",
     "espree": "^3.5.2",
     "esquery": "^1.0.0",
     "lodash": "^4.17.4"
@@ -27,20 +28,20 @@
     "@types/lodash": "^4.14.91",
     "@types/mocha": "^2.2.44",
     "@types/node": "^6.0.85",
-    "babel-eslint": "^8.0.3",
+    "babel-eslint": "^8.1.1",
     "chokidar": "^1.7.0",
     "codecov": "^3.0.0",
     "cross-spawn": "^5.1.0",
     "dts-bundle": "^0.7.3",
-    "eslint": "^4.13.1",
+    "eslint": "^4.14.0",
     "eslint-config-mysticatea": "^12.0.0",
     "fs-extra": "^5.0.0",
     "mocha": "^4.0.1",
     "npm-run-all": "^4.1.2",
     "nyc": "^11.4.1",
     "opener": "^1.4.3",
     "rimraf": "^2.6.2",
-    "rollup": "^0.52.3",
+    "rollup": "^0.53.0",
     "rollup-plugin-node-resolve": "^3.0.0",
     "rollup-plugin-sourcemaps": "^0.4.2",
     "rollup-watch": "^4.3.1",

rollup.config.js

@@ -7,23 +7,28 @@ import resolve from "rollup-plugin-node-resolve"
 import sourcemaps from "rollup-plugin-sourcemaps"
 
 const pkg = require("./package.json")
-const external = [
-    "assert",
-    "events",
-    "path",
-].concat(Object.keys(pkg.dependencies))
+const deps = new Set(
+    [
+        "assert",
+        "events",
+        "path",
+    ].concat(Object.keys(pkg.dependencies))
+)
 
 export default {
-    entry: ".temp/index.js",
-    external,
-    dest: "index.js",
-    format: "cjs",
-    sourceMap: true,
-    sourceMapFile: "index.js.map",
+    input: ".temp/index.js",
+    output: {
+        file: "index.js",
+        format: "cjs",
+        sourcemap: true,
+        sourcemapFile: "index.js.map",
+        strict: true,
+    },
     plugins: [
         sourcemaps(),
-        resolve({external}),
+        resolve(),
     ],
+    external: (id) => deps.has(id) || id.startsWith("lodash"),
     banner: `/**
  * @author Toru Nagashima <https://github.com/mysticatea>
  * @copyright 2017 Toru Nagashima. All rights reserved.

src/ast/nodes.ts

@@ -3,6 +3,7 @@
  * @copyright 2017 Toru Nagashima. All rights reserved.
  * See LICENSE file in root directory for full license.
  */
+import { ScopeManager } from "eslint-scope"
 import { ParseError } from "./errors"
 import { HasLocation } from "./locations"
 import { Token } from "./tokens"
@@ -43,9 +44,9 @@ export type ESLintNode =
  */
 export interface ESLintExtendedProgram {
     ast: ESLintProgram
-    services?: any
-    visitorKeys?: any
-    scope?: any
+    services?: {}
+    visitorKeys?: { [type: string]: string[] }
+    scopeManager?: ScopeManager
 }
 
 export interface ESLintProgram extends HasLocation, HasParent {

src/ast/traverse.ts

@@ -3,105 +3,14 @@
  * @copyright 2017 Toru Nagashima. All rights reserved.
  * See LICENSE file in root directory for full license.
  */
+import Evk, { VisitorKeys } from "eslint-visitor-keys"
 import { Node } from "./nodes"
 
 //------------------------------------------------------------------------------
 // Helpers
 //------------------------------------------------------------------------------
 
-type KeyMap = { [key: string]: string[] | undefined }
-
-const KEYS: KeyMap = {
-    AssignmentExpression: ["left", "right"],
-    AssignmentPattern: ["left", "right"],
-    ArrayExpression: ["elements"],
-    ArrayPattern: ["elements"],
-    ArrowFunctionExpression: ["params", "body"],
-    AwaitExpression: ["argument"],
-    BlockStatement: ["body"],
-    BinaryExpression: ["left", "right"],
-    BreakStatement: ["label"],
-    CallExpression: ["callee", "arguments"],
-    CatchClause: ["param", "body"],
-    ClassBody: ["body"],
-    ClassDeclaration: ["id", "superClass", "body"],
-    ClassExpression: ["id", "superClass", "body"],
-    ConditionalExpression: ["test", "consequent", "alternate"],
-    ContinueStatement: ["label"],
-    DebuggerStatement: [],
-    DirectiveStatement: [],
-    DoWhileStatement: ["body", "test"],
-    EmptyStatement: [],
-    ExportAllDeclaration: ["source"],
-    ExportDefaultDeclaration: ["declaration"],
-    ExportNamedDeclaration: ["declaration", "specifiers", "source"],
-    ExportSpecifier: ["exported", "local"],
-    ExpressionStatement: ["expression"],
-    ForStatement: ["init", "test", "update", "body"],
-    ForInStatement: ["left", "right", "body"],
-    ForOfStatement: ["left", "right", "body"],
-    FunctionDeclaration: ["id", "params", "body"],
-    FunctionExpression: ["id", "params", "body"],
-    Identifier: [],
-    IfStatement: ["test", "consequent", "alternate"],
-    ImportDeclaration: ["specifiers", "source"],
-    ImportDefaultSpecifier: ["local"],
-    ImportNamespaceSpecifier: ["local"],
-    ImportSpecifier: ["imported", "local"],
-    Literal: [],
-    LabeledStatement: ["label", "body"],
-    LogicalExpression: ["left", "right"],
-    MemberExpression: ["object", "property"],
-    MetaProperty: ["meta", "property"],
-    MethodDefinition: ["key", "value"],
-    ModuleSpecifier: [],
-    NewExpression: ["callee", "arguments"],
-    ObjectExpression: ["properties"],
-    ObjectPattern: ["properties"],
-    Program: ["body"],
-    Property: ["key", "value"],
-    RestElement: ["argument"],
-    ReturnStatement: ["argument"],
-    SequenceExpression: ["expressions"],
-    SpreadElement: ["argument"],
-    Super: [],
-    SwitchStatement: ["discriminant", "cases"],
-    SwitchCase: ["test", "consequent"],
-    TaggedTemplateExpression: ["tag", "quasi"],
-    TemplateElement: [],
-    TemplateLiteral: ["quasis", "expressions"],
-    ThisExpression: [],
-    ThrowStatement: ["argument"],
-    TryStatement: ["block", "handler", "finalizer"],
-    UnaryExpression: ["argument"],
-    UpdateExpression: ["argument"],
-    VariableDeclaration: ["declarations"],
-    VariableDeclarator: ["id", "init"],
-    WhileStatement: ["test", "body"],
-    WithStatement: ["object", "body"],
-    YieldExpression: ["argument"],
-
-    // Legacy
-    RestProperty: ["argument"],
-    ExperimentalRestProperty: ["argument"],
-    SpreadProperty: ["argument"],
-    ExperimentalSpreadProperty: ["argument"],
-
-    // JSX
-    JSXIdentifier: [],
-    JSXMemberExpression: ["object", "property"],
-    JSXNamespacedName: ["namespace", "name"],
-    JSXEmptyExpression: [],
-    JSXExpressionContainer: ["expression"],
-    JSXSpreadChild: ["expression"],
-    JSXOpeningElement: ["name", "attributes"],
-    JSXClosingElement: ["name"],
-    JSXAttribute: ["name", "value"],
-    JSXSpreadAttribute: ["argument"],
-    JSXText: [],
-    JSXElement: ["openingElement", "children", "closingElement"],
-
-    // Vue.js
+const KEYS = Evk.unionWith({
     VAttribute: ["key", "value"],
     VDirectiveKey: [],
     VDocumentFragment: ["children"],
@@ -114,7 +23,7 @@ const KEYS: KeyMap = {
     VOnExpression: ["body"],
     VStartTag: ["attributes"],
     VText: [],
-}
+})
 
 /**
  * Check that the given key should be traversed or not.
@@ -159,7 +68,7 @@ function traverse(node: Node, parent: Node | null, visitor: Visitor) {
 
     visitor.enterNode(node, parent)
 
-    const keys = KEYS[node.type] || getFallbackKeys(node)
+    const keys = (visitor.visitorKeys || KEYS)[node.type] || getFallbackKeys(node)
     for (i = 0; i < keys.length; ++i) {
         const child = (node as any)[keys[i]]
 
@@ -183,6 +92,7 @@ function traverse(node: Node, parent: Node | null, visitor: Visitor) {
 //------------------------------------------------------------------------------
 
 export interface Visitor {
+    visitorKeys?: VisitorKeys
     enterNode(node: Node, parent: Node | null): void
     leaveNode(node: Node, parent: Node | null): void
 }

src/external/node-event-generator.ts

@@ -2,16 +2,16 @@
  * This file is copied from `eslint/lib/util/node-event-generator.js`
  */
 import EventEmitter from "events"
-import * as esquery from "esquery"
+import esquery, {Selector} from "esquery"
 import union from "lodash/union"
 import intersection from "lodash/intersection"
 import memoize from "lodash/memoize"
 import {Node} from "../ast"
 
-interface Selector {
+interface NodeSelector {
     rawSelector: string
     isExit: boolean
-    parsedSelector: esquery.Selector
+    parsedSelector: Selector
     listenerTypes: string[] | null
     attributeCount: number
     identifierCount: number
@@ -22,7 +22,7 @@ interface Selector {
 * @param parsedSelector An object (from esquery) describing the matching behavior of the selector
 * @returns The node types that could possibly trigger this selector, or `null` if all node types could trigger it
 */
-function getPossibleTypes(parsedSelector: esquery.Selector): string[] | null {
+function getPossibleTypes(parsedSelector: Selector): string[] | null {
     switch (parsedSelector.type) {
         case "identifier":
             return [parsedSelector.value]
@@ -67,7 +67,7 @@ function getPossibleTypes(parsedSelector: esquery.Selector): string[] | null {
  * @param parsedSelector An object (from esquery) describing the selector's matching behavior
  * @returns The number of class, pseudo-class, and attribute queries in this selector
  */
-function countClassAttributes(parsedSelector: esquery.Selector): number {
+function countClassAttributes(parsedSelector: Selector): number {
     switch (parsedSelector.type) {
         case "child":
         case "descendant":
@@ -96,7 +96,7 @@ function countClassAttributes(parsedSelector: esquery.Selector): number {
  * @param parsedSelector An object (from esquery) describing the selector's matching behavior
  * @returns The number of identifier queries
  */
-function countIdentifiers(parsedSelector: esquery.Selector): number {
+function countIdentifiers(parsedSelector: Selector): number {
     switch (parsedSelector.type) {
         case "child":
         case "descendant":
@@ -127,7 +127,7 @@ function countIdentifiers(parsedSelector: esquery.Selector): number {
  * a value less than 0 if selectorA and selectorB have the same specificity, and selectorA <= selectorB alphabetically
  * a value greater than 0 if selectorA and selectorB have the same specificity, and selectorA > selectorB alphabetically
  */
-function compareSpecificity(selectorA: Selector, selectorB: Selector): number {
+function compareSpecificity(selectorA: NodeSelector, selectorB: NodeSelector): number {
     return selectorA.attributeCount - selectorB.attributeCount ||
         selectorA.identifierCount - selectorB.identifierCount ||
         (selectorA.rawSelector <= selectorB.rawSelector ? -1 : 1)
@@ -139,7 +139,7 @@ function compareSpecificity(selectorA: Selector, selectorB: Selector): number {
  * @returns An object (from esquery) describing the matching behavior of this selector
  * @throws An error if the selector is invalid
  */
-function tryParseSelector(rawSelector: string): esquery.Selector {
+function tryParseSelector(rawSelector: string): Selector {
     try {
         return esquery.parse(rawSelector.replace(/:exit$/, ""))
     }
@@ -156,7 +156,7 @@ function tryParseSelector(rawSelector: string): esquery.Selector {
  * @param {string} rawSelector A raw AST selector
  * @returns {ASTSelector} A selector descriptor
  */
-const parseSelector = memoize<(rawSelector: string) => Selector>(rawSelector => {
+const parseSelector = memoize<(rawSelector: string) => NodeSelector>(rawSelector => {
     const parsedSelector = tryParseSelector(rawSelector)
 
     return {
@@ -189,10 +189,10 @@ export default class NodeEventGenerator {
     emitter: EventEmitter
 
     private currentAncestry: Node[]
-    private enterSelectorsByNodeType: Map<string, Selector[]>
-    private exitSelectorsByNodeType: Map<string, Selector[]>
-    private anyTypeEnterSelectors: Selector[]
-    private anyTypeExitSelectors: Selector[]
+    private enterSelectorsByNodeType: Map<string, NodeSelector[]>
+    private exitSelectorsByNodeType: Map<string, NodeSelector[]>
+    private anyTypeEnterSelectors: NodeSelector[]
+    private anyTypeExitSelectors: NodeSelector[]
 
     /**
     * @param emitter - An event emitter which is the destination of events. This emitter must already
@@ -259,7 +259,7 @@ export default class NodeEventGenerator {
      * @param node The node to check
      * @param selector An AST selector descriptor
      */
-    private applySelector(node: Node, selector: Selector): void {
+    private applySelector(node: Node, selector: NodeSelector): void {
         if (esquery.matches(node, selector.parsedSelector, this.currentAncestry)) {
             this.emitter.emit(selector.rawSelector, node)
         }

src/index.ts

@@ -73,9 +73,9 @@ export function parseForESLint(code: string, options: any): AST.ESLintExtendedPr
         const tokenizer = new HTMLTokenizer(code)
         const rootAST = new HTMLParser(tokenizer, options).parse()
         const locationCalcurator = new LocationCalculator(tokenizer.gaps, tokenizer.lineTerminators)
-        const script = rootAST.children.find(isScriptElement) as AST.VElement | undefined // https://github.com/Microsoft/TypeScript/issues/7657
-        const template = rootAST.children.find(isTemplateElement) as AST.VElement | undefined
-        const templateLangAttr = template && template.startTag.attributes.find(isLang) as AST.VAttribute | undefined
+        const script = rootAST.children.find(isScriptElement)
+        const template = rootAST.children.find(isTemplateElement)
+        const templateLangAttr = template && template.startTag.attributes.find(isLang)
         const templateLang = (templateLangAttr && templateLangAttr.value && templateLangAttr.value.value) || "html"
         const concreteInfo: AST.HasConcreteInfo = {
             tokens: rootAST.tokens,

src/script/index.ts

@@ -30,15 +30,17 @@ interface ESLintCustomParser {
  * 1. Set `node.parent`.
  * 2. Fix `node.range` and `node.loc` for HTML entities.
  *
- * @param ast The AST root node to modify.
+ * @param result The parsing result to modify.
  * @param locationCalculator The location calculator to modify.
  */
-function postprocess(ast: ESLintProgram, locationCalculator: LocationCalculator): void {
+function postprocess(result: ESLintExtendedProgram, locationCalculator: LocationCalculator): void {
     // There are cases which the same node instance appears twice in the tree.
     // E.g. `let {a} = {}` // This `a` appears twice at `Property#key` and `Property#value`.
     const traversed = new Set<Node|number[]>()
 
-    traverseNodes(ast, {
+    traverseNodes(result.ast, {
+        visitorKeys: result.visitorKeys,
+
         enterNode(node, parent) {
             if (!traversed.has(node)) {
                 traversed.add(node)
@@ -52,15 +54,16 @@ function postprocess(ast: ESLintProgram, locationCalculator: LocationCalculator)
                 }
             }
         },
+
         leaveNode() {
             // Do nothing.
         },
     })
 
-    for (const token of ast.tokens || []) {
+    for (const token of result.ast.tokens || []) {
         locationCalculator.fixLocation(token)
     }
-    for (const comment of ast.comments || []) {
+    for (const comment of result.ast.comments || []) {
         locationCalculator.fixLocation(comment)
     }
 }
@@ -158,7 +161,7 @@ function throwErrorAsAdjustingOutsideOfCode(err: any, code: string, locationCalc
 function parseScriptFragment(code: string, locationCalculator: LocationCalculator, parserOptions: any): ESLintExtendedProgram {
     try {
         const result = parseScript(code, parserOptions)
-        postprocess(result.ast, locationCalculator)
+        postprocess(result, locationCalculator)
         return result
     }
     catch (err) {