Update indent rule to support Class static block and typescript-eslint v5(rc) (#51)

* Update indent rule to support typescript-eslint/parser v5.

* fix

* Add testcase

Author: ota-meshi

package.json

@@ -67,8 +67,9 @@
     "@types/eslint-visitor-keys": "^1.0.0",
     "@types/mocha": "^9.0.0",
     "@types/node": "^15.0.1",
-    "@typescript-eslint/eslint-plugin": "^4.22.0",
-    "@typescript-eslint/parser": "^4.22.0",
+    "@typescript-eslint/eslint-plugin": "^5.0.0-0",
+    "@typescript-eslint/parser": "^5.0.0-0",
+    "@typescript-eslint/parser-v4": "npm:@typescript-eslint/parser@4",
     "env-cmd": "^10.1.0",
     "eslint": "^7.25.0",
     "eslint-config-prettier": "^8.3.0",

src/rules/indent-helpers/ts.ts

@@ -4,6 +4,7 @@ import {
   isClosingBracketToken,
   isClosingParenToken,
   isNotClosingParenToken,
+  isNotOpeningBraceToken,
   isOpeningBraceToken,
   isOpeningBracketToken,
   isOpeningParenToken,
@@ -297,15 +298,6 @@ export function defineVisitor(context: IndentContext): NodeListener {
       // A & B
       visitor.TSUnionType(node)
     },
-    TSParenthesizedType(node: TSESTree.TSParenthesizedType) {
-      // (T)
-      offsets.setOffsetElementList(
-        [node.typeAnnotation],
-        sourceCode.getFirstToken(node),
-        sourceCode.getLastToken(node),
-        1,
-      )
-    },
     TSMappedType(node: TSESTree.TSMappedType) {
       // {[key in foo]: bar}
       const leftBraceToken = sourceCode.getFirstToken(node)
@@ -728,8 +720,7 @@ export function defineVisitor(context: IndentContext): NodeListener {
     TSAbstractMethodDefinition(
       node:
         | TSESTree.TSAbstractMethodDefinition
-        | TSESTree.TSAbstractClassProperty
-        | TSESTree.ClassProperty
+        | TSESTree.TSAbstractPropertyDefinition
         | TSESTree.TSEnumMember,
     ) {
       const { keyNode, valueNode } =
@@ -777,7 +768,7 @@ export function defineVisitor(context: IndentContext): NodeListener {
         )
       }
     },
-    TSAbstractClassProperty(node: TSESTree.TSAbstractClassProperty) {
+    TSAbstractPropertyDefinition(node: TSESTree.TSAbstractPropertyDefinition) {
       visitor.TSAbstractMethodDefinition(node)
     },
     TSEnumMember(node: TSESTree.TSEnumMember) {
@@ -951,9 +942,6 @@ export function defineVisitor(context: IndentContext): NodeListener {
     // ----------------------------------------------------------------------
     // NON-STANDARD NODES
     // ----------------------------------------------------------------------
-    ClassProperty(node: TSESTree.ClassProperty) {
-      visitor.TSAbstractMethodDefinition(node)
-    },
     Decorator(node: TSESTree.Decorator) {
       // @Decorator
       const [atToken, secondToken] = sourceCode.getFirstTokens(node, {
@@ -992,6 +980,21 @@ export function defineVisitor(context: IndentContext): NodeListener {
         )
       }
     },
+    StaticBlock(node: TSESTree.StaticBlock) {
+      const firstToken = sourceCode.getFirstToken(node)
+      let next = sourceCode.getTokenAfter(firstToken)
+      while (next && isNotOpeningBraceToken(next)) {
+        offsets.setOffsetToken(next, 0, firstToken)
+        next = sourceCode.getTokenAfter(next)
+      }
+      offsets.setOffsetToken(next, 0, firstToken)
+      offsets.setOffsetElementList(
+        node.body,
+        next!,
+        sourceCode.getLastToken(node),
+        1,
+      )
+    },
     // ----------------------------------------------------------------------
     // SINGLE TOKEN NODES
     // ----------------------------------------------------------------------
@@ -1080,10 +1083,9 @@ export function defineVisitor(context: IndentContext): NodeListener {
   const commonsVisitor: any = {
     // Process semicolons.
     ["TSTypeAliasDeclaration, TSCallSignatureDeclaration, TSConstructSignatureDeclaration, TSImportEqualsDeclaration," +
-      "TSAbstractMethodDefinition, TSAbstractClassProperty, TSEnumMember, ClassProperty," +
-      "TSPropertySignature, TSIndexSignature, TSMethodSignature"](
-      node: ESTree.Node,
-    ) {
+      "TSAbstractMethodDefinition, TSAbstractPropertyDefinition, TSEnumMember," +
+      "TSPropertySignature, TSIndexSignature, TSMethodSignature," +
+      "TSAbstractClassProperty, ClassProperty"](node: ESTree.Node) {
       const firstToken = sourceCode.getFirstToken(node)
       const lastToken = sourceCode.getLastToken(node)
       if (isSemicolonToken(lastToken) && firstToken !== lastToken) {
@@ -1094,6 +1096,71 @@ export function defineVisitor(context: IndentContext): NodeListener {
         }
       }
     },
+    // eslint-disable-next-line complexity -- ignore
+    "*[type=/^TS/]"(node: TSESTree.Node) {
+      if (
+        node.type !== "TSAnyKeyword" &&
+        node.type !== "TSArrayType" &&
+        node.type !== "TSBigIntKeyword" &&
+        node.type !== "TSBooleanKeyword" &&
+        node.type !== "TSConditionalType" &&
+        node.type !== "TSConstructorType" &&
+        node.type !== "TSFunctionType" &&
+        node.type !== "TSImportType" &&
+        node.type !== "TSIndexedAccessType" &&
+        node.type !== "TSInferType" &&
+        node.type !== "TSIntersectionType" &&
+        node.type !== "TSIntrinsicKeyword" &&
+        node.type !== "TSLiteralType" &&
+        node.type !== "TSMappedType" &&
+        node.type !== "TSNamedTupleMember" &&
+        node.type !== "TSNeverKeyword" &&
+        node.type !== "TSNullKeyword" &&
+        node.type !== "TSNumberKeyword" &&
+        node.type !== "TSObjectKeyword" &&
+        node.type !== "TSOptionalType" &&
+        node.type !== "TSRestType" &&
+        node.type !== "TSStringKeyword" &&
+        node.type !== "TSSymbolKeyword" &&
+        node.type !== "TSTemplateLiteralType" &&
+        node.type !== "TSThisType" &&
+        node.type !== "TSTupleType" &&
+        node.type !== "TSTypeLiteral" &&
+        node.type !== "TSTypeOperator" &&
+        node.type !== "TSTypePredicate" &&
+        node.type !== "TSTypeQuery" &&
+        node.type !== "TSTypeReference" &&
+        node.type !== "TSUndefinedKeyword" &&
+        node.type !== "TSUnionType" &&
+        node.type !== "TSUnknownKeyword" &&
+        node.type !== "TSVoidKeyword"
+      ) {
+        return
+      }
+      const typeNode: TSESTree.TypeNode = node
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any -- ignore
+      if ((typeNode.parent as any).type === "TSParenthesizedType") {
+        return
+      }
+      // Process parentheses.
+      let leftToken = sourceCode.getTokenBefore(typeNode)
+      let rightToken = sourceCode.getTokenAfter(typeNode)
+      let firstToken = sourceCode.getFirstToken(typeNode)
+
+      while (
+        leftToken &&
+        isOpeningParenToken(leftToken) &&
+        rightToken &&
+        isClosingParenToken(rightToken)
+      ) {
+        offsets.setOffsetToken(firstToken, 1, leftToken)
+        offsets.setOffsetToken(rightToken, 0, leftToken)
+
+        firstToken = leftToken
+        leftToken = sourceCode.getTokenBefore(leftToken)
+        rightToken = sourceCode.getTokenAfter(rightToken)
+      }
+    },
   }
 
   // eslint-disable-next-line @typescript-eslint/no-explicit-any -- ignore
@@ -1125,11 +1192,34 @@ export function defineVisitor(context: IndentContext): NodeListener {
       }
     },
   }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- ignore
+  const deprecatedVisitor: any = {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- ignore
+    TSParenthesizedType(node: any) {
+      // (T)
+      offsets.setOffsetElementList(
+        [node.typeAnnotation],
+        sourceCode.getFirstToken(node),
+        sourceCode.getLastToken(node),
+        1,
+      )
+    },
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- ignore
+    ClassProperty(node: any) {
+      visitor.TSAbstractMethodDefinition(node)
+    },
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- ignore
+    TSAbstractClassProperty(node: any) {
+      visitor.TSAbstractMethodDefinition(node)
+    },
+  }
   const v: NodeListener = visitor
 
   return {
     ...v,
     ...commonsVisitor,
     ...extendsESVisitor,
+    ...deprecatedVisitor,
   }
 }

tests/fixtures/rules/indent/invalid/ts/ts-static-block01-errors.json

@@ -0,0 +1,37 @@
+[
+  {
+    "message": "Expected indentation of 2 spaces but found 0 spaces.",
+    "line": 3,
+    "column": 1
+  },
+  {
+    "message": "Expected indentation of 4 spaces but found 0 spaces.",
+    "line": 4,
+    "column": 1
+  },
+  {
+    "message": "Expected indentation of 6 spaces but found 0 spaces.",
+    "line": 5,
+    "column": 1
+  },
+  {
+    "message": "Expected indentation of 8 spaces but found 0 spaces.",
+    "line": 6,
+    "column": 1
+  },
+  {
+    "message": "Expected indentation of 6 spaces but found 0 spaces.",
+    "line": 7,
+    "column": 1
+  },
+  {
+    "message": "Expected indentation of 4 spaces but found 0 spaces.",
+    "line": 8,
+    "column": 1
+  },
+  {
+    "message": "Expected indentation of 2 spaces but found 0 spaces.",
+    "line": 9,
+    "column": 1
+  }
+]

tests/fixtures/rules/indent/invalid/ts/ts-static-block01-input.svelte

@@ -0,0 +1,10 @@
+<!-- prettier-ignore -->
+<script lang="ts">
+class Foo {
+static {
+foo(
+arg
+)
+}
+}
+</script>

tests/fixtures/rules/indent/invalid/ts/ts-static-block01-output.svelte

@@ -0,0 +1,10 @@
+<!-- prettier-ignore -->
+<script lang="ts">
+  class Foo {
+    static {
+      foo(
+        arg
+      )
+    }
+  }
+</script>

tests/src/rules/indent.ts

@@ -1,4 +1,5 @@
 import { RuleTester } from "eslint"
+import path from "path"
 import rule from "../../../src/rules/indent"
 import { loadTestCases } from "../../utils/utils"
 
@@ -14,3 +15,26 @@ const tester = new RuleTester({
 })
 
 tester.run("indent", rule as any, loadTestCases("indent"))
+
+const testerForTsParserV4 = new RuleTester({
+  parserOptions: {
+    ecmaVersion: 2020,
+    sourceType: "module",
+    parser: {
+      ts: "@typescript-eslint/parser-v4",
+      js: "espree",
+    },
+  },
+})
+
+describe("use @typescript-eslint/parser@4", () => {
+  testerForTsParserV4.run(
+    "indent",
+    rule as any,
+    loadTestCases("indent", {
+      filter(filename) {
+        return path.basename(path.dirname(filename)) === "ts"
+      },
+    }),
+  )
+})

tests/utils/utils.ts

@@ -56,10 +56,12 @@ function getMinIndent(lines: string[]) {
  */
 export function loadTestCases(
   ruleName: string,
-  _options?: any,
-  additionals?: {
-    valid?: (RuleTester.ValidTestCase | string)[]
-    invalid?: RuleTester.InvalidTestCase[]
+  options?: {
+    additionals?: {
+      valid?: (RuleTester.ValidTestCase | string)[]
+      invalid?: RuleTester.InvalidTestCase[]
+    }
+    filter: (file: string) => boolean
   },
 ): {
   valid: RuleTester.ValidTestCase[]
@@ -74,44 +76,48 @@ export function loadTestCases(
     `../fixtures/rules/${ruleName}/invalid/`,
   )
 
-  const valid = listupInput(validFixtureRoot).map((inputFile) =>
-    getConfig(ruleName, inputFile),
-  )
+  const filter = options?.filter ?? (() => true)
+
+  const valid = listupInput(validFixtureRoot)
+    .filter(filter)
+    .map((inputFile) => getConfig(ruleName, inputFile))
 
   const fixable = plugin.rules[ruleName].meta.fixable != null
 
-  const invalid = listupInput(invalidFixtureRoot).map((inputFile) => {
-    const config = getConfig(ruleName, inputFile)
-    const errorFile = inputFile.replace(/input\.svelte$/u, "errors.json")
-    const outputFile = inputFile.replace(/input\.svelte$/u, "output.svelte")
-    let errors
-    try {
-      errors = fs.readFileSync(errorFile, "utf8")
-    } catch (e) {
-      writeFixtures(ruleName, inputFile)
-      errors = fs.readFileSync(errorFile, "utf8")
-    }
-    config.errors = JSON.parse(errors)
-    if (fixable) {
-      let output
+  const invalid = listupInput(invalidFixtureRoot)
+    .filter(filter)
+    .map((inputFile) => {
+      const config = getConfig(ruleName, inputFile)
+      const errorFile = inputFile.replace(/input\.svelte$/u, "errors.json")
+      const outputFile = inputFile.replace(/input\.svelte$/u, "output.svelte")
+      let errors
       try {
-        output = fs.readFileSync(outputFile, "utf8")
+        errors = fs.readFileSync(errorFile, "utf8")
       } catch (e) {
         writeFixtures(ruleName, inputFile)
-        output = fs.readFileSync(outputFile, "utf8")
+        errors = fs.readFileSync(errorFile, "utf8")
+      }
+      config.errors = JSON.parse(errors)
+      if (fixable) {
+        let output
+        try {
+          output = fs.readFileSync(outputFile, "utf8")
+        } catch (e) {
+          writeFixtures(ruleName, inputFile)
+          output = fs.readFileSync(outputFile, "utf8")
+        }
+        config.output = output
       }
-      config.output = output
-    }
 
-    return config
-  })
+      return config
+    })
 
-  if (additionals) {
-    if (additionals.valid) {
-      valid.push(...additionals.valid)
+  if (options?.additionals) {
+    if (options.additionals.valid) {
+      valid.push(...options.additionals.valid)
     }
-    if (additionals.invalid) {
-      invalid.push(...additionals.invalid)
+    if (options.additionals.invalid) {
+      invalid.push(...options.additionals.invalid)
     }
   }
   for (const test of valid) {