From 651abe56ac5e8fce20ba2d70ee45828f77ae34c4 Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Mon, 9 Feb 2026 02:20:25 +0000 Subject: [PATCH 1/5] feat: add member-ordering rule Co-authored-by: Zack Jackson --- internal/config/config.go | 2 + .../rules/member_ordering/member_ordering.go | 1051 +++++++++++++++++ .../member_ordering/member_ordering_test.go | 161 +++ 3 files changed, 1214 insertions(+) create mode 100644 internal/plugins/typescript/rules/member_ordering/member_ordering.go create mode 100644 internal/plugins/typescript/rules/member_ordering/member_ordering_test.go diff --git a/internal/config/config.go b/internal/config/config.go index c96c48be0..f44a59a1a 100644 --- a/internal/config/config.go +++ b/internal/config/config.go @@ -25,6 +25,7 @@ import ( "github.com/web-infra-dev/rslint/internal/plugins/typescript/rules/consistent_type_imports" "github.com/web-infra-dev/rslint/internal/plugins/typescript/rules/default_param_last" "github.com/web-infra-dev/rslint/internal/plugins/typescript/rules/dot_notation" + "github.com/web-infra-dev/rslint/internal/plugins/typescript/rules/member_ordering" "github.com/web-infra-dev/rslint/internal/plugins/typescript/rules/no_array_constructor" "github.com/web-infra-dev/rslint/internal/plugins/typescript/rules/no_array_delete" "github.com/web-infra-dev/rslint/internal/plugins/typescript/rules/no_base_to_string" @@ -388,6 +389,7 @@ func registerAllTypeScriptEslintPluginRules() { GlobalRuleRegistry.Register("@typescript-eslint/consistent-type-imports", consistent_type_imports.ConsistentTypeImportsRule) GlobalRuleRegistry.Register("@typescript-eslint/default-param-last", default_param_last.DefaultParamLastRule) GlobalRuleRegistry.Register("@typescript-eslint/dot-notation", dot_notation.DotNotationRule) + GlobalRuleRegistry.Register("@typescript-eslint/member-ordering", member_ordering.MemberOrderingRule) GlobalRuleRegistry.Register("@typescript-eslint/no-array-constructor", no_array_constructor.NoArrayConstructorRule) GlobalRuleRegistry.Register("@typescript-eslint/no-array-delete", no_array_delete.NoArrayDeleteRule) GlobalRuleRegistry.Register("@typescript-eslint/no-base-to-string", no_base_to_string.NoBaseToStringRule) diff --git a/internal/plugins/typescript/rules/member_ordering/member_ordering.go b/internal/plugins/typescript/rules/member_ordering/member_ordering.go new file mode 100644 index 000000000..836d28d1a --- /dev/null +++ b/internal/plugins/typescript/rules/member_ordering/member_ordering.go @@ -0,0 +1,1051 @@ +package member_ordering + +import ( + "fmt" + "strings" + "unicode" + "unicode/utf8" + + "github.com/microsoft/typescript-go/shim/ast" + "github.com/web-infra-dev/rslint/internal/rule" + "github.com/web-infra-dev/rslint/internal/utils" +) + +const ( + orderAsWritten = "as-written" + orderAlphabetically = "alphabetically" + orderAlphabeticallyInsensitive = "alphabetically-case-insensitive" + orderNatural = "natural" + orderNaturalInsensitive = "natural-case-insensitive" + + optionalityRequiredFirst = "required-first" + optionalityOptionalFirst = "optional-first" +) + +type memberTypeGroup struct { + members []string + isGroup bool +} + +type parsedOrderConfig struct { + disabled bool + memberTypes []memberTypeGroup + memberTypesNever bool + order string + optionalityOrder string +} + +type ruleOptions struct { + defaultConfig parsedOrderConfig + classes *parsedOrderConfig + classExpressions *parsedOrderConfig + interfaces *parsedOrderConfig + typeLiterals *parsedOrderConfig +} + +var defaultOrder = []string{ + // Index signature + "signature", + "call-signature", + + // Fields + "public-static-field", + "protected-static-field", + "private-static-field", + "#private-static-field", + + "public-decorated-field", + "protected-decorated-field", + "private-decorated-field", + + "public-instance-field", + "protected-instance-field", + "private-instance-field", + "#private-instance-field", + + "public-abstract-field", + "protected-abstract-field", + + "public-field", + "protected-field", + "private-field", + "#private-field", + + "static-field", + "instance-field", + "abstract-field", + + "decorated-field", + + "field", + + // Static initialization + "static-initialization", + + // Constructors + "public-constructor", + "protected-constructor", + "private-constructor", + + "constructor", + + // Accessors + "public-static-accessor", + "protected-static-accessor", + "private-static-accessor", + "#private-static-accessor", + + "public-decorated-accessor", + "protected-decorated-accessor", + "private-decorated-accessor", + + "public-instance-accessor", + "protected-instance-accessor", + "private-instance-accessor", + "#private-instance-accessor", + + "public-abstract-accessor", + "protected-abstract-accessor", + + "public-accessor", + "protected-accessor", + "private-accessor", + "#private-accessor", + + "static-accessor", + "instance-accessor", + "abstract-accessor", + + "decorated-accessor", + + "accessor", + + // Getters + "public-static-get", + "protected-static-get", + "private-static-get", + "#private-static-get", + + "public-decorated-get", + "protected-decorated-get", + "private-decorated-get", + + "public-instance-get", + "protected-instance-get", + "private-instance-get", + "#private-instance-get", + + "public-abstract-get", + "protected-abstract-get", + + "public-get", + "protected-get", + "private-get", + "#private-get", + + "static-get", + "instance-get", + "abstract-get", + + "decorated-get", + + "get", + + // Setters + "public-static-set", + "protected-static-set", + "private-static-set", + "#private-static-set", + + "public-decorated-set", + "protected-decorated-set", + "private-decorated-set", + + "public-instance-set", + "protected-instance-set", + "private-instance-set", + "#private-instance-set", + + "public-abstract-set", + "protected-abstract-set", + + "public-set", + "protected-set", + "private-set", + "#private-set", + + "static-set", + "instance-set", + "abstract-set", + + "decorated-set", + + "set", + + // Methods + "public-static-method", + "protected-static-method", + "private-static-method", + "#private-static-method", + + "public-decorated-method", + "protected-decorated-method", + "private-decorated-method", + + "public-instance-method", + "protected-instance-method", + "private-instance-method", + "#private-instance-method", + + "public-abstract-method", + "protected-abstract-method", + + "public-method", + "protected-method", + "private-method", + "#private-method", + + "static-method", + "instance-method", + "abstract-method", + + "decorated-method", + + "method", +} + +var defaultMemberTypes = memberTypeGroupsFromStrings(defaultOrder) + +var MemberOrderingRule = rule.CreateRule(rule.Rule{ + Name: "member-ordering", + Run: func(ctx rule.RuleContext, rawOpts any) rule.RuleListeners { + options := parseRuleOptions(rawOpts) + + return rule.RuleListeners{ + ast.KindClassDeclaration: func(node *ast.Node) { + members := getClassMembers(node) + if members == nil { + return + } + validateMembersOrder(ctx, members, resolveOrderConfig(options.classes, options.defaultConfig), true) + }, + ast.KindClassExpression: func(node *ast.Node) { + members := getClassMembers(node) + if members == nil { + return + } + validateMembersOrder(ctx, members, resolveOrderConfig(options.classExpressions, options.defaultConfig), true) + }, + ast.KindInterfaceDeclaration: func(node *ast.Node) { + decl := node.AsInterfaceDeclaration() + if decl == nil || decl.Members == nil { + return + } + validateMembersOrder(ctx, decl.Members.Nodes, resolveOrderConfig(options.interfaces, options.defaultConfig), false) + }, + ast.KindTypeLiteral: func(node *ast.Node) { + literal := node.AsTypeLiteralNode() + if literal == nil || literal.Members == nil { + return + } + validateMembersOrder(ctx, literal.Members.Nodes, resolveOrderConfig(options.typeLiterals, options.defaultConfig), false) + }, + } + }, +}) + +func resolveOrderConfig(config *parsedOrderConfig, fallback parsedOrderConfig) parsedOrderConfig { + if config != nil { + return *config + } + return fallback +} + +func parseRuleOptions(raw any) ruleOptions { + defaultConfig := parsedOrderConfig{ + memberTypes: defaultMemberTypes, + order: orderAsWritten, + } + result := ruleOptions{defaultConfig: defaultConfig} + + optsMap := extractOptionsMap(raw) + if optsMap == nil { + return result + } + + if parsed := parseOrderConfig(optsMap["default"], defaultConfig.memberTypes); parsed != nil { + result.defaultConfig = *parsed + } + if parsed := parseOrderConfig(optsMap["classes"], result.defaultConfig.memberTypes); parsed != nil { + result.classes = parsed + } + if parsed := parseOrderConfig(optsMap["classExpressions"], result.defaultConfig.memberTypes); parsed != nil { + result.classExpressions = parsed + } + if parsed := parseOrderConfig(optsMap["interfaces"], result.defaultConfig.memberTypes); parsed != nil { + result.interfaces = parsed + } + if parsed := parseOrderConfig(optsMap["typeLiterals"], result.defaultConfig.memberTypes); parsed != nil { + result.typeLiterals = parsed + } + + return result +} + +func extractOptionsMap(raw any) map[string]interface{} { + if raw == nil { + return nil + } + if arr, ok := raw.([]interface{}); ok { + if len(arr) == 0 { + return nil + } + opts, _ := arr[0].(map[string]interface{}) + return opts + } + opts, _ := raw.(map[string]interface{}) + return opts +} + +func parseOrderConfig(raw any, defaultMemberTypes []memberTypeGroup) *parsedOrderConfig { + if raw == nil { + return nil + } + + switch value := raw.(type) { + case string: + if value == "never" { + return &parsedOrderConfig{disabled: true} + } + case []interface{}: + return &parsedOrderConfig{ + memberTypes: parseMemberTypeGroups(value), + order: orderAsWritten, + } + case []string: + return &parsedOrderConfig{ + memberTypes: memberTypeGroupsFromStrings(value), + order: orderAsWritten, + } + case map[string]interface{}: + config := parsedOrderConfig{ + order: orderAsWritten, + } + + if orderValue, ok := value["order"].(string); ok { + config.order = orderValue + } + if optionality, ok := value["optionalityOrder"].(string); ok { + config.optionalityOrder = optionality + } + + if memberTypes, ok := value["memberTypes"]; ok { + switch typed := memberTypes.(type) { + case string: + if typed == "never" { + config.memberTypesNever = true + } else { + config.memberTypes = []memberTypeGroup{{members: []string{typed}}} + } + case []interface{}: + config.memberTypes = parseMemberTypeGroups(typed) + case []string: + config.memberTypes = memberTypeGroupsFromStrings(typed) + } + } else { + config.memberTypes = defaultMemberTypes + } + + return &config + } + + return nil +} + +func memberTypeGroupsFromStrings(values []string) []memberTypeGroup { + groups := make([]memberTypeGroup, 0, len(values)) + for _, value := range values { + groups = append(groups, memberTypeGroup{members: []string{value}}) + } + return groups +} + +func parseMemberTypeGroups(values []interface{}) []memberTypeGroup { + groups := make([]memberTypeGroup, 0, len(values)) + for _, value := range values { + switch typed := value.(type) { + case string: + groups = append(groups, memberTypeGroup{members: []string{typed}}) + case []interface{}: + groupMembers := make([]string, 0, len(typed)) + for _, groupItem := range typed { + if str, ok := groupItem.(string); ok { + groupMembers = append(groupMembers, str) + } + } + groups = append(groups, memberTypeGroup{members: groupMembers, isGroup: true}) + case []string: + groupMembers := make([]string, 0, len(typed)) + groupMembers = append(groupMembers, typed...) + groups = append(groups, memberTypeGroup{members: groupMembers, isGroup: true}) + } + } + return groups +} + +func validateMembersOrder(ctx rule.RuleContext, members []*ast.Node, config parsedOrderConfig, supportsModifiers bool) { + if config.disabled { + return + } + + order := config.order + if order == "" { + order = orderAsWritten + } + + memberTypes := config.memberTypes + if config.memberTypesNever { + memberTypes = nil + } + + checkAlphaSortForAllMembers := func(memberSet []*ast.Node) { + hasAlphaSort := order != "" && order != orderAsWritten + if !hasAlphaSort || len(memberTypes) == 0 { + return + } + for _, group := range groupMembersByType(memberSet, memberTypes, supportsModifiers, ctx.SourceFile) { + checkAlphaSort(ctx, group, order) + } + } + + checkOrder := func(memberSet []*ast.Node) bool { + hasAlphaSort := order != "" && order != orderAsWritten + if len(memberTypes) > 0 { + grouped := checkGroupSort(ctx, memberSet, memberTypes, supportsModifiers) + if grouped == nil { + checkAlphaSortForAllMembers(memberSet) + return false + } + if hasAlphaSort { + for _, group := range grouped { + checkAlphaSort(ctx, group, order) + } + } + } else if hasAlphaSort { + return checkAlphaSort(ctx, memberSet, order) + } + return false + } + + if config.optionalityOrder == "" { + checkOrder(members) + return + } + + switchIndex := firstOptionalitySwitchIndex(members) + if switchIndex != -1 { + if !checkRequiredOrder(ctx, members, config.optionalityOrder) { + return + } + checkOrder(members[:switchIndex]) + checkOrder(members[switchIndex:]) + } else { + checkOrder(members) + } +} + +func firstOptionalitySwitchIndex(members []*ast.Node) int { + for i := 1; i < len(members); i++ { + if isMemberOptional(members[i]) != isMemberOptional(members[i-1]) { + return i + } + } + return -1 +} + +func checkGroupSort(ctx rule.RuleContext, members []*ast.Node, memberTypes []memberTypeGroup, supportsModifiers bool) [][]*ast.Node { + previousRanks := make([]int, 0, 4) + memberGroups := make([][]*ast.Node, 0, 4) + isCorrectlySorted := true + + for _, member := range members { + rank := getRank(ctx.SourceFile, member, memberTypes, supportsModifiers) + if rank == -1 { + continue + } + + if len(previousRanks) == 0 { + previousRanks = append(previousRanks, rank) + memberGroups = append(memberGroups, []*ast.Node{member}) + continue + } + + lastRank := previousRanks[len(previousRanks)-1] + if rank < lastRank { + ctx.ReportNode(member, messageIncorrectGroupOrder( + getMemberName(ctx, member), + getLowestRank(previousRanks, rank, memberTypes), + )) + isCorrectlySorted = false + } else if rank == lastRank { + memberGroups[len(memberGroups)-1] = append(memberGroups[len(memberGroups)-1], member) + } else { + previousRanks = append(previousRanks, rank) + memberGroups = append(memberGroups, []*ast.Node{member}) + } + } + + if !isCorrectlySorted { + return nil + } + return memberGroups +} + +func checkAlphaSort(ctx rule.RuleContext, members []*ast.Node, order string) bool { + previousName := "" + isCorrectlySorted := true + + for _, member := range members { + name := getMemberName(ctx, member) + if name == "" { + continue + } + + if naturalOutOfOrder(name, previousName, order) { + ctx.ReportNode(member, messageIncorrectOrder(name, previousName)) + isCorrectlySorted = false + } + previousName = name + } + + return isCorrectlySorted +} + +func naturalOutOfOrder(name string, previousName string, order string) bool { + if name == previousName { + return false + } + + switch order { + case orderAlphabetically: + return name < previousName + case orderAlphabeticallyInsensitive: + return strings.ToLower(name) < strings.ToLower(previousName) + case orderNatural: + return naturalCompare(name, previousName) != 1 + case orderNaturalInsensitive: + return naturalCompare(strings.ToLower(name), strings.ToLower(previousName)) != 1 + default: + return false + } +} + +func checkRequiredOrder(ctx rule.RuleContext, members []*ast.Node, optionalityOrder string) bool { + switchIndex := firstOptionalitySwitchIndex(members) + if switchIndex == -1 { + return true + } + + report := func(member *ast.Node) { + requiredLabel := "required" + if optionalityOrder == optionalityOptionalFirst { + requiredLabel = "optional" + } + ctx.ReportNode(member, messageIncorrectRequiredMembersOrder(getMemberName(ctx, member), requiredLabel)) + } + + firstIsOptional := isMemberOptional(members[0]) + if firstIsOptional != (optionalityOrder == optionalityOptionalFirst) { + report(members[0]) + return false + } + + for i := switchIndex + 1; i < len(members); i++ { + if isMemberOptional(members[i]) != isMemberOptional(members[switchIndex]) { + report(members[switchIndex]) + return false + } + } + + return true +} + +func groupMembersByType(members []*ast.Node, memberTypes []memberTypeGroup, supportsModifiers bool, sourceFile *ast.SourceFile) [][]*ast.Node { + grouped := make([][]*ast.Node, 0, 4) + if len(members) == 0 { + return grouped + } + + memberRanks := make([]int, len(members)) + for i, member := range members { + memberRanks[i] = getRank(sourceFile, member, memberTypes, supportsModifiers) + } + + previousRank := 0 + hasPrevious := false + + for i, member := range members { + if i == len(members)-1 { + return grouped + } + currentRank := memberRanks[i] + nextRank := memberRanks[i+1] + + if hasPrevious && currentRank == previousRank { + grouped[len(grouped)-1] = append(grouped[len(grouped)-1], member) + } else if currentRank == nextRank { + grouped = append(grouped, []*ast.Node{member}) + previousRank = currentRank + hasPrevious = true + } + } + + return grouped +} + +func getLowestRank(ranks []int, target int, order []memberTypeGroup) string { + if len(ranks) == 0 { + return "" + } + + lowest := ranks[len(ranks)-1] + for _, rank := range ranks { + if rank > target { + if rank < lowest { + lowest = rank + } + } + } + + if lowest < 0 || lowest >= len(order) { + return "" + } + + entries := order[lowest] + var rankNames []string + if entries.isGroup { + for _, rank := range entries.members { + rankNames = append(rankNames, strings.ReplaceAll(rank, "-", " ")) + } + } else if len(entries.members) > 0 { + rankNames = append(rankNames, strings.ReplaceAll(entries.members[0], "-", " ")) + } + + return strings.Join(rankNames, ", ") +} + +func getRank(sourceFile *ast.SourceFile, node *ast.Node, orderConfig []memberTypeGroup, supportsModifiers bool) int { + if node.Kind == ast.KindMethodDeclaration { + method := node.AsMethodDeclaration() + if method != nil && method.Body == nil { + return -1 + } + } + if node.Kind == ast.KindConstructor { + constructor := node.AsConstructorDeclaration() + if constructor != nil && constructor.Body == nil { + return -1 + } + } + + nodeType := getNodeType(node) + if nodeType == "" { + if len(orderConfig) == 0 { + return -1 + } + return len(orderConfig) - 1 + } + + abstract := ast.GetCombinedModifierFlags(node)&ast.ModifierFlagsAbstract != 0 + scope := "instance" + if ast.IsStatic(node) { + scope = "static" + } else if abstract { + scope = "abstract" + } + + accessibility := getAccessibility(node) + + memberGroups := make([]string, 0, 6) + if supportsModifiers { + decorated := ast.HasDecorators(node) + if decorated && supportsDecorators(nodeType) { + memberGroups = append(memberGroups, accessibility+"-decorated-"+nodeType) + memberGroups = append(memberGroups, "decorated-"+nodeType) + if nodeType == "readonly-field" { + memberGroups = append(memberGroups, accessibility+"-decorated-field") + memberGroups = append(memberGroups, "decorated-field") + } + } + + if nodeType != "readonly-signature" && nodeType != "signature" && nodeType != "static-initialization" { + if nodeType != "constructor" { + memberGroups = append(memberGroups, accessibility+"-"+scope+"-"+nodeType) + memberGroups = append(memberGroups, scope+"-"+nodeType) + if nodeType == "readonly-field" { + memberGroups = append(memberGroups, accessibility+"-"+scope+"-field") + memberGroups = append(memberGroups, scope+"-field") + } + } + memberGroups = append(memberGroups, accessibility+"-"+nodeType) + if nodeType == "readonly-field" { + memberGroups = append(memberGroups, accessibility+"-field") + } + } + } + + memberGroups = append(memberGroups, nodeType) + if nodeType == "readonly-signature" { + memberGroups = append(memberGroups, "signature") + } else if nodeType == "readonly-field" { + memberGroups = append(memberGroups, "field") + } + + return getRankOrder(memberGroups, orderConfig) +} + +func supportsDecorators(nodeType string) bool { + switch nodeType { + case "readonly-field", "field", "method", "accessor", "get", "set": + return true + default: + return false + } +} + +func getRankOrder(memberGroups []string, orderConfig []memberTypeGroup) int { + for _, memberGroup := range memberGroups { + for index, memberType := range orderConfig { + if memberType.isGroup { + for _, entry := range memberType.members { + if entry == memberGroup { + return index + } + } + continue + } + if len(memberType.members) > 0 && memberType.members[0] == memberGroup { + return index + } + } + } + return -1 +} + +func getNodeType(node *ast.Node) string { + switch node.Kind { + case ast.KindMethodDeclaration, ast.KindMethodSignature: + return "method" + case ast.KindConstructor, ast.KindConstructSignature: + return "constructor" + case ast.KindCallSignature: + return "call-signature" + case ast.KindGetAccessor: + return "get" + case ast.KindSetAccessor: + return "set" + case ast.KindPropertySignature: + if isReadonly(node) { + return "readonly-field" + } + return "field" + case ast.KindPropertyDeclaration: + if ast.IsAutoAccessorPropertyDeclaration(node) { + return "accessor" + } + property := node.AsPropertyDeclaration() + if property != nil && property.Initializer != nil { + if property.Initializer.Kind == ast.KindFunctionExpression || property.Initializer.Kind == ast.KindArrowFunction { + return "method" + } + } + if isReadonly(node) { + return "readonly-field" + } + return "field" + case ast.KindIndexSignature: + if isReadonly(node) { + return "readonly-signature" + } + return "signature" + case ast.KindClassStaticBlockDeclaration: + return "static-initialization" + } + + return "" +} + +func getAccessibility(node *ast.Node) string { + flags := ast.GetCombinedModifierFlags(node) + if flags&ast.ModifierFlagsPrivate != 0 { + return "private" + } + if flags&ast.ModifierFlagsProtected != 0 { + return "protected" + } + if flags&ast.ModifierFlagsPublic != 0 { + return "public" + } + + nameNode := getNameNode(node) + if nameNode != nil && nameNode.Kind == ast.KindPrivateIdentifier { + return "#private" + } + + return "public" +} + +func getMemberName(ctx rule.RuleContext, node *ast.Node) string { + switch node.Kind { + case ast.KindPropertySignature, ast.KindMethodSignature, ast.KindPropertyDeclaration, ast.KindMethodDeclaration, + ast.KindGetAccessor, ast.KindSetAccessor: + return getMemberRawName(ctx, getNameNode(node)) + case ast.KindConstructor: + return "constructor" + case ast.KindConstructSignature: + return "new" + case ast.KindCallSignature: + return "call" + case ast.KindIndexSignature: + return getNameFromIndexSignature(node) + case ast.KindClassStaticBlockDeclaration: + return "static block" + } + return "" +} + +func getNameNode(node *ast.Node) *ast.Node { + switch node.Kind { + case ast.KindPropertyDeclaration: + if decl := node.AsPropertyDeclaration(); decl != nil { + return decl.Name() + } + case ast.KindMethodDeclaration: + if decl := node.AsMethodDeclaration(); decl != nil { + return decl.Name() + } + case ast.KindGetAccessor: + if decl := node.AsGetAccessorDeclaration(); decl != nil { + return decl.Name() + } + case ast.KindSetAccessor: + if decl := node.AsSetAccessorDeclaration(); decl != nil { + return decl.Name() + } + case ast.KindPropertySignature: + if decl := node.AsPropertySignatureDeclaration(); decl != nil { + return decl.Name() + } + case ast.KindMethodSignature: + if decl := node.AsMethodSignatureDeclaration(); decl != nil { + return decl.Name() + } + } + return nil +} + +func getMemberRawName(ctx rule.RuleContext, nameNode *ast.Node) string { + if nameNode == nil { + return "" + } + + switch nameNode.Kind { + case ast.KindIdentifier: + return nameNode.AsIdentifier().Text + case ast.KindPrivateIdentifier: + return nameNode.AsPrivateIdentifier().Text + case ast.KindStringLiteral: + return nameNode.AsStringLiteral().Text + case ast.KindNumericLiteral: + return nameNode.AsNumericLiteral().Text + case ast.KindBigIntLiteral: + return nameNode.AsBigIntLiteral().Text + case ast.KindComputedPropertyName: + expr := nameNode.AsComputedPropertyName().Expression + if expr != nil && ast.IsLiteralExpression(expr) { + switch expr.Kind { + case ast.KindStringLiteral: + return expr.AsStringLiteral().Text + case ast.KindNumericLiteral: + return expr.AsNumericLiteral().Text + case ast.KindBigIntLiteral: + return expr.AsBigIntLiteral().Text + default: + return expr.Text() + } + } + } + + trimmed := utils.TrimNodeTextRange(ctx.SourceFile, nameNode) + return ctx.SourceFile.Text()[trimmed.Pos():trimmed.End()] +} + +func getNameFromIndexSignature(node *ast.Node) string { + indexSig := node.AsIndexSignatureDeclaration() + if indexSig == nil || indexSig.Parameters == nil { + return "(index signature)" + } + + for _, param := range indexSig.Parameters.Nodes { + if param.Kind != ast.KindParameter { + continue + } + name := param.AsParameterDeclaration().Name() + if name != nil && name.Kind == ast.KindIdentifier { + return name.AsIdentifier().Text + } + } + + return "(index signature)" +} + +func isMemberOptional(node *ast.Node) bool { + switch node.Kind { + case ast.KindPropertySignature: + if decl := node.AsPropertySignatureDeclaration(); decl != nil { + return decl.PostfixToken != nil && decl.PostfixToken.Kind == ast.KindQuestionToken + } + case ast.KindMethodSignature: + if decl := node.AsMethodSignatureDeclaration(); decl != nil { + return decl.PostfixToken != nil && decl.PostfixToken.Kind == ast.KindQuestionToken + } + case ast.KindPropertyDeclaration: + if decl := node.AsPropertyDeclaration(); decl != nil { + return decl.PostfixToken != nil && decl.PostfixToken.Kind == ast.KindQuestionToken + } + case ast.KindMethodDeclaration: + if decl := node.AsMethodDeclaration(); decl != nil { + return decl.PostfixToken != nil && decl.PostfixToken.Kind == ast.KindQuestionToken + } + } + return false +} + +func isReadonly(node *ast.Node) bool { + return ast.GetCombinedModifierFlags(node)&ast.ModifierFlagsReadonly != 0 +} + +func getClassMembers(node *ast.Node) []*ast.Node { + switch node.Kind { + case ast.KindClassDeclaration: + classDecl := node.AsClassDeclaration() + if classDecl == nil || classDecl.Members == nil { + return nil + } + return classDecl.Members.Nodes + case ast.KindClassExpression: + classExpr := node.AsClassExpression() + if classExpr == nil || classExpr.Members == nil { + return nil + } + return classExpr.Members.Nodes + default: + return nil + } +} + +func naturalCompare(first string, second string) int { + if first == second { + return 0 + } + + firstIndex := 0 + secondIndex := 0 + + for firstIndex < len(first) && secondIndex < len(second) { + firstRune, firstSize := utf8.DecodeRuneInString(first[firstIndex:]) + secondRune, secondSize := utf8.DecodeRuneInString(second[secondIndex:]) + + if unicode.IsDigit(firstRune) && unicode.IsDigit(secondRune) { + firstStart := firstIndex + for firstIndex < len(first) { + r, size := utf8.DecodeRuneInString(first[firstIndex:]) + if !unicode.IsDigit(r) { + break + } + firstIndex += size + } + + secondStart := secondIndex + for secondIndex < len(second) { + r, size := utf8.DecodeRuneInString(second[secondIndex:]) + if !unicode.IsDigit(r) { + break + } + secondIndex += size + } + + firstNumber := first[firstStart:firstIndex] + secondNumber := second[secondStart:secondIndex] + + firstTrimmed := strings.TrimLeft(firstNumber, "0") + secondTrimmed := strings.TrimLeft(secondNumber, "0") + if firstTrimmed == "" { + firstTrimmed = "0" + } + if secondTrimmed == "" { + secondTrimmed = "0" + } + + if len(firstTrimmed) != len(secondTrimmed) { + if len(firstTrimmed) < len(secondTrimmed) { + return -1 + } + return 1 + } + if firstTrimmed != secondTrimmed { + if firstTrimmed < secondTrimmed { + return -1 + } + return 1 + } + if len(firstNumber) != len(secondNumber) { + if len(firstNumber) < len(secondNumber) { + return -1 + } + return 1 + } + + continue + } + + if firstRune != secondRune { + if firstRune < secondRune { + return -1 + } + return 1 + } + + firstIndex += firstSize + secondIndex += secondSize + } + + if firstIndex == len(first) && secondIndex == len(second) { + return 0 + } + if firstIndex == len(first) { + return -1 + } + return 1 +} + +func messageIncorrectGroupOrder(name string, rank string) rule.RuleMessage { + return rule.RuleMessage{ + Id: "incorrectGroupOrder", + Description: fmt.Sprintf("Member %s should be declared before all %s definitions.", name, rank), + } +} + +func messageIncorrectOrder(member string, before string) rule.RuleMessage { + return rule.RuleMessage{ + Id: "incorrectOrder", + Description: fmt.Sprintf("Member %s should be declared before member %s.", member, before), + } +} + +func messageIncorrectRequiredMembersOrder(member string, optionalOrRequired string) rule.RuleMessage { + return rule.RuleMessage{ + Id: "incorrectRequiredMembersOrder", + Description: fmt.Sprintf("Member %s should be declared after all %s members.", member, optionalOrRequired), + } +} diff --git a/internal/plugins/typescript/rules/member_ordering/member_ordering_test.go b/internal/plugins/typescript/rules/member_ordering/member_ordering_test.go new file mode 100644 index 000000000..36dfd6507 --- /dev/null +++ b/internal/plugins/typescript/rules/member_ordering/member_ordering_test.go @@ -0,0 +1,161 @@ +package member_ordering + +import ( + "testing" + + "github.com/web-infra-dev/rslint/internal/plugins/typescript/rules/fixtures" + "github.com/web-infra-dev/rslint/internal/rule_tester" +) + +func TestMemberOrderingRule(t *testing.T) { + rule_tester.RunRuleTester(fixtures.GetRootDir(), "tsconfig.json", t, &MemberOrderingRule, []rule_tester.ValidTestCase{ + { + Code: `class Foo { + a: string; + constructor() {} + b(): void {} +}`, + }, + { + Code: `class Foo { + [A: string]: any; + [a: string]: any; + static C: boolean; + static d: boolean; + b: any; + B: any; + get e(): string {} + get E(): string {} + private imPrivate() {} + private ImPrivate() {} +}`, + Options: []interface{}{ + map[string]interface{}{ + "default": map[string]interface{}{ + "order": "alphabetically-case-insensitive", + }, + }, + }, + }, + }, []rule_tester.InvalidTestCase{ + { + Code: `class Foo { + method() {} + field: string; +}`, + Options: []interface{}{ + map[string]interface{}{ + "default": []interface{}{"field", "method"}, + }, + }, + Errors: []rule_tester.InvalidTestCaseError{ + { + MessageId: "incorrectGroupOrder", + Line: 3, + Column: 3, + }, + }, + }, + { + Code: `interface Foo { + b: string; + a: string; +}`, + Options: []interface{}{ + map[string]interface{}{ + "default": map[string]interface{}{ + "memberTypes": "never", + "order": "alphabetically", + }, + }, + }, + Errors: []rule_tester.InvalidTestCaseError{ + { + MessageId: "incorrectOrder", + Line: 3, + Column: 3, + }, + }, + }, + { + Code: `interface Foo { + b?: string; + a: string; +}`, + Options: []interface{}{ + map[string]interface{}{ + "default": map[string]interface{}{ + "memberTypes": "never", + "optionalityOrder": "required-first", + "order": "as-written", + }, + }, + }, + Errors: []rule_tester.InvalidTestCaseError{ + { + MessageId: "incorrectRequiredMembersOrder", + Line: 2, + Column: 3, + }, + }, + }, + { + Code: `class Foo { + method() {} + static {} +}`, + Options: []interface{}{ + map[string]interface{}{ + "default": []interface{}{"static-initialization", "method"}, + }, + }, + Errors: []rule_tester.InvalidTestCaseError{ + { + MessageId: "incorrectGroupOrder", + Line: 3, + Column: 3, + }, + }, + }, + { + Code: `class Foo { + a: string; + readonly b: string; +}`, + Options: []interface{}{ + map[string]interface{}{ + "default": []interface{}{"readonly-field", "field"}, + }, + }, + Errors: []rule_tester.InvalidTestCaseError{ + { + MessageId: "incorrectGroupOrder", + Line: 3, + Column: 3, + }, + }, + }, + { + Code: `interface Foo { + a1: string; + a10: string; + a5: string; +}`, + Options: []interface{}{ + map[string]interface{}{ + "default": map[string]interface{}{ + "memberTypes": "never", + "order": "natural", + }, + }, + }, + Errors: []rule_tester.InvalidTestCaseError{ + { + MessageId: "incorrectOrder", + Line: 4, + Column: 3, + }, + }, + }, + }) +} From aa93764249d612ddb7790221a39fff526d5a8f74 Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Mon, 9 Feb 2026 02:40:26 +0000 Subject: [PATCH 2/5] fix: handle abstract member ordering Co-authored-by: Zack Jackson --- .../rules/member_ordering/member_ordering.go | 23 +- packages/rslint-test-tools/rstest.config.mts | 2 +- .../member-ordering.test.ts.snap | 4316 +++++++++++++++++ 3 files changed, 4328 insertions(+), 13 deletions(-) create mode 100644 packages/rslint-test-tools/tests/typescript-eslint/rules/__snapshots__/member-ordering.test.ts.snap diff --git a/internal/plugins/typescript/rules/member_ordering/member_ordering.go b/internal/plugins/typescript/rules/member_ordering/member_ordering.go index 836d28d1a..25d85dce5 100644 --- a/internal/plugins/typescript/rules/member_ordering/member_ordering.go +++ b/internal/plugins/typescript/rules/member_ordering/member_ordering.go @@ -635,9 +635,18 @@ func getLowestRank(ranks []int, target int, order []memberTypeGroup) string { } func getRank(sourceFile *ast.SourceFile, node *ast.Node, orderConfig []memberTypeGroup, supportsModifiers bool) int { + nodeType := getNodeType(node) + if nodeType == "" { + if len(orderConfig) == 0 { + return -1 + } + return len(orderConfig) - 1 + } + + abstract := ast.HasSyntacticModifier(node, ast.ModifierFlagsAbstract) if node.Kind == ast.KindMethodDeclaration { method := node.AsMethodDeclaration() - if method != nil && method.Body == nil { + if method != nil && method.Body == nil && !abstract { return -1 } } @@ -647,16 +656,6 @@ func getRank(sourceFile *ast.SourceFile, node *ast.Node, orderConfig []memberTyp return -1 } } - - nodeType := getNodeType(node) - if nodeType == "" { - if len(orderConfig) == 0 { - return -1 - } - return len(orderConfig) - 1 - } - - abstract := ast.GetCombinedModifierFlags(node)&ast.ModifierFlagsAbstract != 0 scope := "instance" if ast.IsStatic(node) { scope = "static" @@ -922,7 +921,7 @@ func isMemberOptional(node *ast.Node) bool { } func isReadonly(node *ast.Node) bool { - return ast.GetCombinedModifierFlags(node)&ast.ModifierFlagsReadonly != 0 + return ast.HasSyntacticModifier(node, ast.ModifierFlagsReadonly) } func getClassMembers(node *ast.Node) []*ast.Node { diff --git a/packages/rslint-test-tools/rstest.config.mts b/packages/rslint-test-tools/rstest.config.mts index 6da674759..4109616ce 100644 --- a/packages/rslint-test-tools/rstest.config.mts +++ b/packages/rslint-test-tools/rstest.config.mts @@ -37,7 +37,7 @@ export default defineConfig({ // './tests/typescript-eslint/rules/explicit-module-boundary-types.test.ts', // './tests/typescript-eslint/rules/init-declarations.test.ts', // './tests/typescript-eslint/rules/max-params.test.ts', - // './tests/typescript-eslint/rules/member-ordering.test.ts', + './tests/typescript-eslint/rules/member-ordering.test.ts', // './tests/typescript-eslint/rules/member-ordering/member-ordering-alphabetically-case-insensitive-order.test.ts', // './tests/typescript-eslint/rules/member-ordering/member-ordering-alphabetically-order.test.ts', // './tests/typescript-eslint/rules/member-ordering/member-ordering-natural-case-insensitive-order.test.ts', diff --git a/packages/rslint-test-tools/tests/typescript-eslint/rules/__snapshots__/member-ordering.test.ts.snap b/packages/rslint-test-tools/tests/typescript-eslint/rules/__snapshots__/member-ordering.test.ts.snap new file mode 100644 index 000000000..b41304039 --- /dev/null +++ b/packages/rslint-test-tools/tests/typescript-eslint/rules/__snapshots__/member-ordering.test.ts.snap @@ -0,0 +1,4316 @@ +// Rstest Snapshot v1 + +exports[`member-ordering > invalid 1`] = ` +{ + "code": " +// no accessibility === public +interface Foo { + [Z: string]: any; + A: string; + B: string; + C: string; + D: string; + E: string; + F: string; + G(); + H(); + I(); + J(); + K(); + L(); + new (); +} + ", + "diagnostics": [ + { + "message": "Member new should be declared before all method definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 10, + "line": 17, + }, + "start": { + "column": 3, + "line": 17, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 1, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 2`] = ` +{ + "code": " +interface X { + a: unknown; + (): void; + b(): void; +} + ", + "diagnostics": [ + { + "message": "Member call should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 12, + "line": 4, + }, + "start": { + "column": 3, + "line": 4, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 1, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 3`] = ` +{ + "code": " +// no accessibility === public +interface Foo { + A: string; + B: string; + C: string; + D: string; + E: string; + F: string; + G(); + H(); + I(); + J(); + K(); + L(); + new (); + [Z: string]: any; +} + ", + "diagnostics": [ + { + "message": "Member G should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 7, + "line": 10, + }, + "start": { + "column": 3, + "line": 10, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member H should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 7, + "line": 11, + }, + "start": { + "column": 3, + "line": 11, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member I should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 7, + "line": 12, + }, + "start": { + "column": 3, + "line": 12, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member J should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 7, + "line": 13, + }, + "start": { + "column": 3, + "line": 13, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member K should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 7, + "line": 14, + }, + "start": { + "column": 3, + "line": 14, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member L should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 7, + "line": 15, + }, + "start": { + "column": 3, + "line": 15, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member new should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 10, + "line": 16, + }, + "start": { + "column": 3, + "line": 16, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member Z should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 20, + "line": 17, + }, + "start": { + "column": 3, + "line": 17, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 8, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 4`] = ` +{ + "code": " +// no accessibility === public +interface Foo { + A: string; + B: string; + C: string; + D: string; + E: string; + F: string; + G(); + H(); + I(); + J(); + K(); + L(); + new (); + [Z: string]: any; +} + ", + "diagnostics": [ + { + "message": "Member G should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 7, + "line": 10, + }, + "start": { + "column": 3, + "line": 10, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member H should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 7, + "line": 11, + }, + "start": { + "column": 3, + "line": 11, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member I should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 7, + "line": 12, + }, + "start": { + "column": 3, + "line": 12, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member J should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 7, + "line": 13, + }, + "start": { + "column": 3, + "line": 13, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member K should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 7, + "line": 14, + }, + "start": { + "column": 3, + "line": 14, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member L should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 7, + "line": 15, + }, + "start": { + "column": 3, + "line": 15, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member new should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 10, + "line": 16, + }, + "start": { + "column": 3, + "line": 16, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member Z should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 20, + "line": 17, + }, + "start": { + "column": 3, + "line": 17, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 8, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 5`] = ` +{ + "code": " +// no accessibility === public +interface Foo { + A: string; + B: string; + C: string; + D: string; + E: string; + F: string; + G(); + H(); + I(); + J(); + K(); + L(); + new (); + [Z: string]: any; +} + ", + "diagnostics": [ + { + "message": "Member G should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 7, + "line": 10, + }, + "start": { + "column": 3, + "line": 10, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member H should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 7, + "line": 11, + }, + "start": { + "column": 3, + "line": 11, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member I should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 7, + "line": 12, + }, + "start": { + "column": 3, + "line": 12, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member J should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 7, + "line": 13, + }, + "start": { + "column": 3, + "line": 13, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member K should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 7, + "line": 14, + }, + "start": { + "column": 3, + "line": 14, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member L should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 7, + "line": 15, + }, + "start": { + "column": 3, + "line": 15, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member new should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 10, + "line": 16, + }, + "start": { + "column": 3, + "line": 16, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member Z should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 20, + "line": 17, + }, + "start": { + "column": 3, + "line": 17, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 8, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 6`] = ` +{ + "code": " +// no accessibility === public +interface Foo { + [Z: string]: any; + new (); + A: string; + G(); + B: string; + H(); + C: string; + I(); + D: string; + J(); + E: string; + K(); + F: string; + L(); +} + ", + "diagnostics": [ + { + "message": "Member B should be declared before all method definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 13, + "line": 8, + }, + "start": { + "column": 3, + "line": 8, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member C should be declared before all method definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 13, + "line": 10, + }, + "start": { + "column": 3, + "line": 10, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member D should be declared before all method definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 13, + "line": 12, + }, + "start": { + "column": 3, + "line": 12, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member E should be declared before all method definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 13, + "line": 14, + }, + "start": { + "column": 3, + "line": 14, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member F should be declared before all method definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 13, + "line": 16, + }, + "start": { + "column": 3, + "line": 16, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 5, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 7`] = ` +{ + "code": " +// no accessibility === public +type Foo = { + [Z: string]: any; + A: string; + B: string; + C: string; + D: string; + E: string; + F: string; + G(); + H(); + I(); + J(); + K(); + L(); + new (); +}; + ", + "diagnostics": [ + { + "message": "Member new should be declared before all method definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 10, + "line": 17, + }, + "start": { + "column": 3, + "line": 17, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 1, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 8`] = ` +{ + "code": " +// no accessibility === public +type Foo = { + A: string; + B: string; + C: string; + D: string; + E: string; + F: string; + G(); + H(); + I(); + J(); + K(); + L(); + [Z: string]: any; + new (); +}; + ", + "diagnostics": [ + { + "message": "Member G should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 7, + "line": 10, + }, + "start": { + "column": 3, + "line": 10, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member H should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 7, + "line": 11, + }, + "start": { + "column": 3, + "line": 11, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member I should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 7, + "line": 12, + }, + "start": { + "column": 3, + "line": 12, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member J should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 7, + "line": 13, + }, + "start": { + "column": 3, + "line": 13, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member K should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 7, + "line": 14, + }, + "start": { + "column": 3, + "line": 14, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member L should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 7, + "line": 15, + }, + "start": { + "column": 3, + "line": 15, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member Z should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 20, + "line": 16, + }, + "start": { + "column": 3, + "line": 16, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member new should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 10, + "line": 17, + }, + "start": { + "column": 3, + "line": 17, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 8, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 9`] = ` +{ + "code": " +// no accessibility === public +type Foo = { + [Z: string]: any; + A: string; + B: string; + C: string; + D: string; + E: string; + F: string; + G(); + H(); + I(); + J(); + K(); + L(); + new (); +}; + ", + "diagnostics": [ + { + "message": "Member G should be declared before all signature definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 7, + "line": 11, + }, + "start": { + "column": 3, + "line": 11, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member H should be declared before all signature definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 7, + "line": 12, + }, + "start": { + "column": 3, + "line": 12, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member I should be declared before all signature definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 7, + "line": 13, + }, + "start": { + "column": 3, + "line": 13, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member J should be declared before all signature definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 7, + "line": 14, + }, + "start": { + "column": 3, + "line": 14, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member K should be declared before all signature definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 7, + "line": 15, + }, + "start": { + "column": 3, + "line": 15, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member L should be declared before all signature definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 7, + "line": 16, + }, + "start": { + "column": 3, + "line": 16, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member new should be declared before all signature definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 10, + "line": 17, + }, + "start": { + "column": 3, + "line": 17, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 7, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 10`] = ` +{ + "code": " +// no accessibility === public +type Foo = { + A: string; + B: string; + C: string; + D: string; + E: string; + F: string; + G(); + H(); + I(); + J(); + K(); + L(); + new (); + [Z: string]: any; +}; + ", + "diagnostics": [ + { + "message": "Member G should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 7, + "line": 10, + }, + "start": { + "column": 3, + "line": 10, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member H should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 7, + "line": 11, + }, + "start": { + "column": 3, + "line": 11, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member I should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 7, + "line": 12, + }, + "start": { + "column": 3, + "line": 12, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member J should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 7, + "line": 13, + }, + "start": { + "column": 3, + "line": 13, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member K should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 7, + "line": 14, + }, + "start": { + "column": 3, + "line": 14, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member L should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 7, + "line": 15, + }, + "start": { + "column": 3, + "line": 15, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member new should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 10, + "line": 16, + }, + "start": { + "column": 3, + "line": 16, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member Z should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 20, + "line": 17, + }, + "start": { + "column": 3, + "line": 17, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 8, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 11`] = ` +{ + "code": " +// no accessibility === public +type Foo = { + new (); + [Z: string]: any; + A: string; + G(); + B: string; + H(); + C: string; + I(); + D: string; + J(); + E: string; + K(); + F: string; + L(); +}; + ", + "diagnostics": [ + { + "message": "Member B should be declared before all method definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 13, + "line": 8, + }, + "start": { + "column": 3, + "line": 8, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member C should be declared before all method definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 13, + "line": 10, + }, + "start": { + "column": 3, + "line": 10, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member D should be declared before all method definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 13, + "line": 12, + }, + "start": { + "column": 3, + "line": 12, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member E should be declared before all method definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 13, + "line": 14, + }, + "start": { + "column": 3, + "line": 14, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member F should be declared before all method definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 13, + "line": 16, + }, + "start": { + "column": 3, + "line": 16, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 5, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 12`] = ` +{ + "code": " +class Foo { + [Z: string]: any; + public static A: string = ''; + protected static B: string = ''; + private static C: string = ''; + static #C: string = ''; + public D: string = ''; + protected E: string = ''; + private F: string = ''; + #F: string = ''; + constructor() {} + public J() {} + protected K() {} + private L() {} + #L() {} + public static G() {} + protected static H() {} + private static I() {} + static #I() {} +} + ", + "diagnostics": [ + { + "message": "Member G should be declared before all public instance method definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 23, + "line": 17, + }, + "start": { + "column": 3, + "line": 17, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member H should be declared before all public instance method definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 26, + "line": 18, + }, + "start": { + "column": 3, + "line": 18, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member I should be declared before all public instance method definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 24, + "line": 19, + }, + "start": { + "column": 3, + "line": 19, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member #I should be declared before all public instance method definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 17, + "line": 20, + }, + "start": { + "column": 3, + "line": 20, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 4, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 13`] = ` +{ + "code": " +class Foo { + constructor() {} + public static A: string = ''; + protected static B: string = ''; + private static C: string = ''; + static #C: string = ''; + public D: string = ''; + protected E: string = ''; + private F: string = ''; + #F: string = ''; + public J() {} + protected K() {} + private L() {} + #L() {} + public static G() {} + protected static H() {} + private static I() {} + static #I() {} + [Z: string]: any; +} + ", + "diagnostics": [ + { + "message": "Member A should be declared before all constructor definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 32, + "line": 4, + }, + "start": { + "column": 3, + "line": 4, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member B should be declared before all constructor definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 35, + "line": 5, + }, + "start": { + "column": 3, + "line": 5, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member C should be declared before all constructor definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 33, + "line": 6, + }, + "start": { + "column": 3, + "line": 6, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member #C should be declared before all constructor definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 26, + "line": 7, + }, + "start": { + "column": 3, + "line": 7, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member D should be declared before all constructor definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 25, + "line": 8, + }, + "start": { + "column": 3, + "line": 8, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member E should be declared before all constructor definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 28, + "line": 9, + }, + "start": { + "column": 3, + "line": 9, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member F should be declared before all constructor definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 26, + "line": 10, + }, + "start": { + "column": 3, + "line": 10, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member #F should be declared before all constructor definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 19, + "line": 11, + }, + "start": { + "column": 3, + "line": 11, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 8, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 14`] = ` +{ + "code": " +class Foo { + constructor() {} + protected static B: string = ''; + private static C: string = ''; + public D: string = ''; + protected E: string = ''; + private F: string = ''; + public static G() {} + public static A: string; + protected static H() {} + private static I() {} + public J() {} + protected K() {} + private L() {} +} + ", + "diagnostics": [ + { + "message": "Member A should be declared before all method definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 27, + "line": 10, + }, + "start": { + "column": 3, + "line": 10, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 1, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 15`] = ` +{ + "code": " +class Foo { + protected static H() {} + private static I() {} + public J() {} + protected K() {} + private L() {} + public static A: string; + public static G() {} + protected static B: string = ''; + private static C: string = ''; + public D: string = ''; + protected E: string = ''; + private F: string = ''; + constructor() {} +} + ", + "diagnostics": [ + { + "message": "Member G should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 23, + "line": 9, + }, + "start": { + "column": 3, + "line": 9, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 1, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 16`] = ` +{ + "code": " +class Foo { + public static G() {} + protected static H() {} + protected static B: string = ''; + private static I() {} + public J() {} + protected K() {} + private L() {} + public static A: string; + constructor() {} + private static C: string = ''; + public D: string = ''; + protected E: string = ''; + private F: string = ''; +} + ", + "diagnostics": [ + { + "message": "Member I should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 24, + "line": 6, + }, + "start": { + "column": 3, + "line": 6, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member J should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 16, + "line": 7, + }, + "start": { + "column": 3, + "line": 7, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member K should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 19, + "line": 8, + }, + "start": { + "column": 3, + "line": 8, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member L should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 17, + "line": 9, + }, + "start": { + "column": 3, + "line": 9, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member constructor should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 19, + "line": 11, + }, + "start": { + "column": 3, + "line": 11, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 5, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 17`] = ` +{ + "code": " +class Foo { + public static A: string; + public static G() {} + protected static H() {} + private static I() {} + public J() {} + protected K() {} + private L() {} + constructor() {} + protected static B: string = ''; + private static C: string = ''; + public D: string = ''; + protected E: string = ''; + private F: string = ''; +} + ", + "diagnostics": [ + { + "message": "Member G should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 23, + "line": 4, + }, + "start": { + "column": 3, + "line": 4, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member H should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 26, + "line": 5, + }, + "start": { + "column": 3, + "line": 5, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member I should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 24, + "line": 6, + }, + "start": { + "column": 3, + "line": 6, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member J should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 16, + "line": 7, + }, + "start": { + "column": 3, + "line": 7, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member K should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 19, + "line": 8, + }, + "start": { + "column": 3, + "line": 8, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member L should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 17, + "line": 9, + }, + "start": { + "column": 3, + "line": 9, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member constructor should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 19, + "line": 10, + }, + "start": { + "column": 3, + "line": 10, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 7, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 18`] = ` +{ + "code": " +class Foo { + private L() {} + public J() {} + public static G() {} + protected static H() {} + private static I() {} + protected K() {} + constructor() {} + public D: string = ''; + private static C: string = ''; + public static A: string; + private static C: string = ''; + protected static B: string = ''; + private F: string = ''; + protected static B: string = ''; + protected E: string = ''; +} + ", + "diagnostics": [ + { + "message": "Member A should be declared before all private field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 27, + "line": 12, + }, + "start": { + "column": 3, + "line": 12, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member F should be declared before all protected field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 26, + "line": 15, + }, + "start": { + "column": 3, + "line": 15, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 2, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 19`] = ` +{ + "code": " +class Foo { + public static G() {} + private static I() {} + public J() {} + protected static H() {} + private L() {} + protected K() {} + public D: string = ''; + constructor() {} + public static A: string; + protected static B: string = ''; + protected E: string = ''; + private static C: string = ''; + private F: string = ''; +} + ", + "diagnostics": [ + { + "message": "Member H should be declared before all public instance method definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 26, + "line": 6, + }, + "start": { + "column": 3, + "line": 6, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member constructor should be declared before all public field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 19, + "line": 10, + }, + "start": { + "column": 3, + "line": 10, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 2, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 20`] = ` +{ + "code": " +class Foo { + public J() {} + public static G() {} + public D: string = ''; + public static A: string = ''; + private L() {} + constructor() {} + protected K() {} + protected static H() {} + private static I() {} + protected static B: string = ''; + private static C: string = ''; + protected E: string = ''; + private F: string = ''; +} + ", + "diagnostics": [ + { + "message": "Member constructor should be declared before all method definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 19, + "line": 8, + }, + "start": { + "column": 3, + "line": 8, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 1, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 21`] = ` +{ + "code": " +class Foo { + public J() {} + private static I() {} + public static G() {} + protected static H() {} + protected K() {} + private L() {} + constructor() {} + public static A: string; + private F: string = ''; + protected static B: string = ''; + public D: string = ''; + private static C: string = ''; + protected E: string = ''; +} + ", + "diagnostics": [ + { + "message": "Member G should be declared before all private static method definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 23, + "line": 5, + }, + "start": { + "column": 3, + "line": 5, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member H should be declared before all private static method definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 26, + "line": 6, + }, + "start": { + "column": 3, + "line": 6, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 2, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 22`] = ` +{ + "code": " +class Foo { + private static I() {} + protected static H() {} + protected static B: string = ''; + public static G() {} + public J() {} + protected K() {} + private static C: string = ''; + private L() {} + private F: string = ''; + protected E: string = ''; + public static A: string; + public D: string = ''; + constructor() {} +} + ", + "diagnostics": [ + { + "message": "Member L should be declared before all protected static field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 17, + "line": 10, + }, + "start": { + "column": 3, + "line": 10, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 1, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 23`] = ` +{ + "code": " +class Foo { + private L() {} + private static I() {} + protected static H() {} + public static G() {} + protected static B: string = ''; + public J() {} + protected K() {} + private static C: string = ''; + private F: string = ''; + protected E: string = ''; + public static A: string; + public D: string = ''; + constructor() {} +} + ", + "diagnostics": [ + { + "message": "Member J should be declared before all protected static field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 16, + "line": 8, + }, + "start": { + "column": 3, + "line": 8, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 1, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 24`] = ` +{ + "code": " +const foo = class Foo { + public static A: string = ''; + protected static B: string = ''; + private static C: string = ''; + public D: string = ''; + protected E: string = ''; + private F: string = ''; + constructor() {} + public J() {} + protected K() {} + private L() {} + public static G() {} + protected static H() {} + private static I() {} +}; + ", + "diagnostics": [ + { + "message": "Member G should be declared before all public instance method definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 23, + "line": 13, + }, + "start": { + "column": 3, + "line": 13, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member H should be declared before all public instance method definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 26, + "line": 14, + }, + "start": { + "column": 3, + "line": 14, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member I should be declared before all public instance method definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 24, + "line": 15, + }, + "start": { + "column": 3, + "line": 15, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 3, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 25`] = ` +{ + "code": " +const foo = class { + [Z: string]: any; + constructor() {} + public static A: string = ''; + protected static B: string = ''; + private static C: string = ''; + public D: string = ''; + protected E: string = ''; + private F: string = ''; + public J() {} + protected K() {} + private L() {} + public static G() {} + protected static H() {} + private static I() {} +}; + ", + "diagnostics": [ + { + "message": "Member A should be declared before all constructor definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 32, + "line": 5, + }, + "start": { + "column": 3, + "line": 5, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member B should be declared before all constructor definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 35, + "line": 6, + }, + "start": { + "column": 3, + "line": 6, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member C should be declared before all constructor definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 33, + "line": 7, + }, + "start": { + "column": 3, + "line": 7, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member D should be declared before all constructor definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 25, + "line": 8, + }, + "start": { + "column": 3, + "line": 8, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member E should be declared before all constructor definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 28, + "line": 9, + }, + "start": { + "column": 3, + "line": 9, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member F should be declared before all constructor definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 26, + "line": 10, + }, + "start": { + "column": 3, + "line": 10, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 6, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 26`] = ` +{ + "code": " +const foo = class { + constructor() {} + protected static B: string = ''; + private static C: string = ''; + public D: string = ''; + protected E: string = ''; + private F: string = ''; + [Z: string]: any; + public static G() {} + public static A: string; + protected static H() {} + private static I() {} + public J() {} + protected K() {} + private L() {} +}; + ", + "diagnostics": [ + { + "message": "Member A should be declared before all method definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 27, + "line": 11, + }, + "start": { + "column": 3, + "line": 11, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 1, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 27`] = ` +{ + "code": " +const foo = class { + protected static H() {} + private static I() {} + public J() {} + protected K() {} + private L() {} + public static A: string; + public static G() {} + protected static B: string = ''; + private static C: string = ''; + public D: string = ''; + protected E: string = ''; + private F: string = ''; + constructor() {} +}; + ", + "diagnostics": [ + { + "message": "Member G should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 23, + "line": 9, + }, + "start": { + "column": 3, + "line": 9, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 1, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 28`] = ` +{ + "code": " +const foo = class { + public static G() {} + protected static H() {} + protected static B: string = ''; + private static I() {} + public J() {} + protected K() {} + private L() {} + public static A: string; + constructor() {} + [Z: string]: any; + private static C: string = ''; + public D: string = ''; + protected E: string = ''; + private F: string = ''; +}; + ", + "diagnostics": [ + { + "message": "Member I should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 24, + "line": 6, + }, + "start": { + "column": 3, + "line": 6, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member J should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 16, + "line": 7, + }, + "start": { + "column": 3, + "line": 7, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member K should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 19, + "line": 8, + }, + "start": { + "column": 3, + "line": 8, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member L should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 17, + "line": 9, + }, + "start": { + "column": 3, + "line": 9, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member constructor should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 19, + "line": 11, + }, + "start": { + "column": 3, + "line": 11, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 5, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 29`] = ` +{ + "code": " +const foo = class { + public static A: string; + public static G() {} + protected static H() {} + private static I() {} + public J() {} + protected K() {} + private L() {} + constructor() {} + protected static B: string = ''; + private static C: string = ''; + public D: string = ''; + protected E: string = ''; + private F: string = ''; +}; + ", + "diagnostics": [ + { + "message": "Member G should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 23, + "line": 4, + }, + "start": { + "column": 3, + "line": 4, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member H should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 26, + "line": 5, + }, + "start": { + "column": 3, + "line": 5, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member I should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 24, + "line": 6, + }, + "start": { + "column": 3, + "line": 6, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member J should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 16, + "line": 7, + }, + "start": { + "column": 3, + "line": 7, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member K should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 19, + "line": 8, + }, + "start": { + "column": 3, + "line": 8, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member L should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 17, + "line": 9, + }, + "start": { + "column": 3, + "line": 9, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member constructor should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 19, + "line": 10, + }, + "start": { + "column": 3, + "line": 10, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 7, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 30`] = ` +{ + "code": " +const foo = class { + private L() {} + public J() {} + public static G() {} + protected static H() {} + private static I() {} + protected K() {} + constructor() {} + public D: string = ''; + private static C: string = ''; + public static A: string; + private static C: string = ''; + protected static B: string = ''; + private F: string = ''; + protected static B: string = ''; + protected E: string = ''; +}; + ", + "diagnostics": [ + { + "message": "Member A should be declared before all private field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 27, + "line": 12, + }, + "start": { + "column": 3, + "line": 12, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member F should be declared before all protected field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 26, + "line": 15, + }, + "start": { + "column": 3, + "line": 15, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 2, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 31`] = ` +{ + "code": " +const foo = class { + public static G() {} + private static I() {} + public J() {} + protected static H() {} + private L() {} + protected K() {} + public D: string = ''; + constructor() {} + public static A: string; + protected static B: string = ''; + protected E: string = ''; + private static C: string = ''; + private F: string = ''; +}; + ", + "diagnostics": [ + { + "message": "Member H should be declared before all public instance method definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 26, + "line": 6, + }, + "start": { + "column": 3, + "line": 6, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member constructor should be declared before all public field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 19, + "line": 10, + }, + "start": { + "column": 3, + "line": 10, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 2, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 32`] = ` +{ + "code": " +const foo = class { + public J() {} + public static G() {} + public D: string = ''; + public static A: string = ''; + private L() {} + constructor() {} + protected K() {} + protected static H() {} + private static I() {} + protected static B: string = ''; + private static C: string = ''; + protected E: string = ''; + private F: string = ''; +}; + ", + "diagnostics": [ + { + "message": "Member constructor should be declared before all method definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 19, + "line": 8, + }, + "start": { + "column": 3, + "line": 8, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 1, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 33`] = ` +{ + "code": " +const foo = class { + public J() {} + private static I() {} + public static G() {} + protected static H() {} + protected K() {} + private L() {} + constructor() {} + public static A: string; + private F: string = ''; + protected static B: string = ''; + public D: string = ''; + private static C: string = ''; + protected E: string = ''; +}; + ", + "diagnostics": [ + { + "message": "Member G should be declared before all private static method definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 23, + "line": 5, + }, + "start": { + "column": 3, + "line": 5, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member H should be declared before all private static method definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 26, + "line": 6, + }, + "start": { + "column": 3, + "line": 6, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 2, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 34`] = ` +{ + "code": " +const foo = class { + private static I() {} + protected static H() {} + protected static B: string = ''; + public static G() {} + public J() {} + protected K() {} + private static C: string = ''; + private L() {} + private F: string = ''; + protected E: string = ''; + public static A: string; + public D: string = ''; + constructor() {} +}; + ", + "diagnostics": [ + { + "message": "Member L should be declared before all protected static field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 17, + "line": 10, + }, + "start": { + "column": 3, + "line": 10, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 1, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 35`] = ` +{ + "code": " +const foo = class { + private L() {} + private static I() {} + protected static H() {} + public static G() {} + protected static B: string = ''; + public J() {} + protected K() {} + private static C: string = ''; + private F: string = ''; + protected E: string = ''; + public static A: string; + public D: string = ''; + constructor() {} +}; + ", + "diagnostics": [ + { + "message": "Member J should be declared before all protected static field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 16, + "line": 8, + }, + "start": { + "column": 3, + "line": 8, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 1, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 36`] = ` +{ + "code": " +class Foo { + K = () => {}; + A: string; + constructor() {} + [Z: string]: any; + J() {} +} + ", + "diagnostics": [ + { + "message": "Member A should be declared before all public instance method definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 13, + "line": 4, + }, + "start": { + "column": 3, + "line": 4, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member constructor should be declared before all public instance method definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 19, + "line": 5, + }, + "start": { + "column": 3, + "line": 5, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member Z should be declared before all public instance method definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 20, + "line": 6, + }, + "start": { + "column": 3, + "line": 6, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 3, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 37`] = ` +{ + "code": " +class Foo { + J() {} + constructor() {} + K = () => {}; + A: string; + [Z: string]: any; +} + ", + "diagnostics": [ + { + "message": "Member K should be declared before all constructor definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 16, + "line": 5, + }, + "start": { + "column": 3, + "line": 5, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 1, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 38`] = ` +{ + "code": " +class Foo { + J() {} + constructor() {} + K = () => {}; + L: () => {}; + A: string; +} + ", + "diagnostics": [ + { + "message": "Member K should be declared before all constructor definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 16, + "line": 5, + }, + "start": { + "column": 3, + "line": 5, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 1, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 39`] = ` +{ + "code": " +interface Foo { + K: () => {}; + J(); + A: string; +} + ", + "diagnostics": [ + { + "message": "Member A should be declared before all method definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 13, + "line": 5, + }, + "start": { + "column": 3, + "line": 5, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 1, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 40`] = ` +{ + "code": " +type Foo = { + K: () => {}; + J(); + A: string; +}; + ", + "diagnostics": [ + { + "message": "Member A should be declared before all method definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 13, + "line": 5, + }, + "start": { + "column": 3, + "line": 5, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 1, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 41`] = ` +{ + "code": " +type Foo = { + A: string; + K: () => {}; + J(); +}; + ", + "diagnostics": [ + { + "message": "Member J should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 7, + "line": 5, + }, + "start": { + "column": 3, + "line": 5, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 1, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 42`] = ` +{ + "code": " +abstract class Foo { + abstract A(): void; + B: string; +} + ", + "diagnostics": [ + { + "message": "Member B should be declared before all public abstract method definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 13, + "line": 4, + }, + "start": { + "column": 3, + "line": 4, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 1, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 43`] = ` +{ + "code": " +abstract class Foo { + abstract A: () => {}; + B: string; +} + ", + "diagnostics": [ + { + "message": "Member B should be declared before all public abstract field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 13, + "line": 4, + }, + "start": { + "column": 3, + "line": 4, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 1, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 44`] = ` +{ + "code": " +abstract class Foo { + abstract A: () => {}; + B: string; + public C() {} + private D() {} + abstract E() {} +} + ", + "diagnostics": [ + { + "message": "Member B should be declared before all public abstract field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 13, + "line": 4, + }, + "start": { + "column": 3, + "line": 4, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 1, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 45`] = ` +{ + "code": " +class Foo { + C: number; + [A: string]: number; + public static D() {} + static [B: string]: number; +} + ", + "diagnostics": [ + { + "message": "Member D should be declared before all signature definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 23, + "line": 5, + }, + "start": { + "column": 3, + "line": 5, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 1, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 46`] = ` +{ + "code": " +abstract class Foo { + abstract B: string; + abstract A(): void; + public C() {} +} + ", + "diagnostics": [ + { + "message": "Member A should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 22, + "line": 4, + }, + "start": { + "column": 3, + "line": 4, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member C should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 16, + "line": 5, + }, + "start": { + "column": 3, + "line": 5, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 2, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 47`] = ` +{ + "code": " +// no accessibility === public +class Foo { + B: string; + @Dec() A: string = ''; + C: string = ''; + constructor() {} + D() {} + E() {} +} + ", + "diagnostics": [ + { + "message": "Member A should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 25, + "line": 5, + }, + "start": { + "column": 3, + "line": 5, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 1, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 48`] = ` +{ + "code": " +class Foo { + A() {} + + @Decorator() + B() {} +} + ", + "diagnostics": [ + { + "message": "Member B should be declared before all method definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 9, + "line": 6, + }, + "start": { + "column": 3, + "line": 5, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 1, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 49`] = ` +{ + "code": " +class Foo { + @Decorator() C() {} + A() {} +} + ", + "diagnostics": [ + { + "message": "Member A should be declared before all decorated method definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 9, + "line": 4, + }, + "start": { + "column": 3, + "line": 4, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 1, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 50`] = ` +{ + "code": " +class Foo { + A(): void; + B(): void; + private C() {} + constructor() {} + @Dec() private D() {} +} + ", + "diagnostics": [ + { + "message": "Member D should be declared before all private method definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 24, + "line": 7, + }, + "start": { + "column": 3, + "line": 7, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 1, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 51`] = ` +{ + "code": " +class Foo { + A: string; + get B() {} + constructor() {} + set B() {} + get C() {} + set C() {} + D(): void; +} + ", + "diagnostics": [ + { + "message": "Member constructor should be declared before all get, set definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 19, + "line": 5, + }, + "start": { + "column": 3, + "line": 5, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 1, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 52`] = ` +{ + "code": " +class Foo { + A: string; + private C() {} + constructor() {} + @Dec() private B: string; + set D() {} + E(): void; +} + ", + "diagnostics": [ + { + "message": "Member constructor should be declared before all private decorated field, public set, private method definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 19, + "line": 5, + }, + "start": { + "column": 3, + "line": 5, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 1, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 53`] = ` +{ + "code": " +class Foo { + A: string; + constructor() {} + get B() {} + set B() {} + get C() {} + set C() {} + D(): void; +} + ", + "diagnostics": [ + { + "message": "Member C should be declared before all set definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 13, + "line": 7, + }, + "start": { + "column": 3, + "line": 7, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 1, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 54`] = ` +{ + "code": " +class Foo { + static {} + m() {} + f = 1; +} + ", + "diagnostics": [ + { + "message": "Member m should be declared before all static initialization definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 9, + "line": 4, + }, + "start": { + "column": 3, + "line": 4, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member f should be declared before all static initialization definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 9, + "line": 5, + }, + "start": { + "column": 3, + "line": 5, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 2, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 55`] = ` +{ + "code": " +class Foo { + m() {} + f = 1; + static {} +} + ", + "diagnostics": [ + { + "message": "Member static block should be declared before all method definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 12, + "line": 5, + }, + "start": { + "column": 3, + "line": 5, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 1, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 56`] = ` +{ + "code": " +class Foo { + f = 1; + static {} + m() {} +} + ", + "diagnostics": [ + { + "message": "Member static block should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 12, + "line": 4, + }, + "start": { + "column": 3, + "line": 4, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 1, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 57`] = ` +{ + "code": " +class Foo { + static {} + f = 1; + m() {} +} + ", + "diagnostics": [ + { + "message": "Member f should be declared before all static initialization definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 9, + "line": 4, + }, + "start": { + "column": 3, + "line": 4, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 1, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 58`] = ` +{ + "code": " +class Foo { + private mp() {} + static {} + public m() {} + @dec + md() {} +} + ", + "diagnostics": [ + { + "message": "Member static block should be declared before all method definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 12, + "line": 4, + }, + "start": { + "column": 3, + "line": 4, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member md should be declared before all method definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 10, + "line": 7, + }, + "start": { + "column": 3, + "line": 6, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 2, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 59`] = ` +{ + "code": " +// no accessibility === public +class Foo { + #imPrivate() {} + imPublic() {} +} + ", + "diagnostics": [ + { + "message": "Member imPublic should be declared before all #private method definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 16, + "line": 5, + }, + "start": { + "column": 3, + "line": 5, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 1, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 60`] = ` +{ + "code": " +// no accessibility === public +class Foo { + #imPrivate() {} + private imPrivate() {} +} + ", + "diagnostics": [ + { + "message": "Member imPrivate should be declared before all #private method definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 25, + "line": 5, + }, + "start": { + "column": 3, + "line": 5, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 1, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 61`] = ` +{ + "code": " +// no accessibility === public +class Foo { + static C: boolean; + [B: string]: any; + private A() {} +} + ", + "diagnostics": [ + { + "message": "Member B should be declared before all public static field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 20, + "line": 5, + }, + "start": { + "column": 3, + "line": 5, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 1, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 62`] = ` +{ + "code": " +// no accessibility === public +class Foo { + static C: boolean; + [B: string]: any; +} + ", + "diagnostics": [ + { + "message": "Member B should be declared before member C.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 20, + "line": 5, + }, + "start": { + "column": 3, + "line": 5, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 1, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 63`] = ` +{ + "code": " +// no accessibility === public +class Foo { + private imPrivate() {} + #imPrivate() {} +} + ", + "diagnostics": [ + { + "message": "Member #imPrivate should be declared before all private method definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 18, + "line": 5, + }, + "start": { + "column": 3, + "line": 5, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 1, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 64`] = ` +{ + "code": " +// no accessibility === public +class Foo { + B: string; + readonly A: string = ''; + C: string = ''; + constructor() {} + D() {} + E() {} +} + ", + "diagnostics": [ + { + "message": "Member A should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 27, + "line": 5, + }, + "start": { + "column": 3, + "line": 5, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 1, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 65`] = ` +{ + "code": " +class Foo { + A: string; + private C() {} + constructor() {} + private readonly B: string; + set D() {} + E(): void; +} + ", + "diagnostics": [ + { + "message": "Member constructor should be declared before all public set, private method definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 19, + "line": 5, + }, + "start": { + "column": 3, + "line": 5, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member B should be declared before all public field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 30, + "line": 6, + }, + "start": { + "column": 3, + "line": 6, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 2, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 66`] = ` +{ + "code": " +abstract class Foo { + @Dec public readonly A: string; + public readonly B: string; + public static readonly C: string; + static readonly #D: string; + readonly #E: string; + + @Dec public F: string; + public G: string; + public static H: string; + static readonly #I: string; + readonly #J: string; +} + ", + "diagnostics": [ + { + "message": "Member F should be declared before all readonly field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 25, + "line": 9, + }, + "start": { + "column": 3, + "line": 9, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member #I should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 30, + "line": 12, + }, + "start": { + "column": 3, + "line": 12, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member #J should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 23, + "line": 13, + }, + "start": { + "column": 3, + "line": 13, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 3, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 67`] = ` +{ + "code": " +abstract class Foo { + @Dec public readonly DA: string; + @Dec protected readonly DB: string; + @Dec private readonly DC: string; + + public static readonly SA: string; + protected static readonly SB: string; + private static readonly SC: string; + static readonly #SD: string; + + public readonly IA: string; + protected readonly IB: string; + private readonly IC: string; + readonly #ID: string; + + public abstract readonly AA: string; + protected abstract readonly AB: string; +} + ", + "diagnostics": [ + { + "message": "Member AA should be declared before all static readonly field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 39, + "line": 17, + }, + "start": { + "column": 3, + "line": 17, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member AB should be declared before all static readonly field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 42, + "line": 18, + }, + "start": { + "column": 3, + "line": 18, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 2, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 68`] = ` +{ + "code": " +interface Foo { + readonly A: string; + readonly B: string; + + C: string; + D: string; +} + ", + "diagnostics": [ + { + "message": "Member C should be declared before all readonly field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 13, + "line": 6, + }, + "start": { + "column": 3, + "line": 6, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member D should be declared before all readonly field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 13, + "line": 7, + }, + "start": { + "column": 3, + "line": 7, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 2, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 69`] = ` +{ + "code": " +interface Foo { + [i: number]: string; + readonly [i: string]: string; + + A: string; + readonly B: string; +} + ", + "diagnostics": [ + { + "message": "Member i should be declared before all signature definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 32, + "line": 4, + }, + "start": { + "column": 3, + "line": 4, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member B should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 22, + "line": 7, + }, + "start": { + "column": 3, + "line": 7, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 2, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 70`] = ` +{ + "code": " +class Foo { + accessor bar; + + baz() {} +} + ", + "diagnostics": [ + { + "message": "Member baz should be declared before all accessor definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 11, + "line": 5, + }, + "start": { + "column": 3, + "line": 5, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 1, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 71`] = ` +{ + "code": " +interface Foo { + y(): void; + get x(): number; +} + ", + "diagnostics": [ + { + "message": "Member x should be declared before all method definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 19, + "line": 4, + }, + "start": { + "column": 3, + "line": 4, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 1, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 72`] = ` +{ + "code": " +interface Foo { + get x(): number; + y(): void; +} + ", + "diagnostics": [ + { + "message": "Member y should be declared before all get definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 13, + "line": 4, + }, + "start": { + "column": 3, + "line": 4, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 1, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 73`] = ` +{ + "code": " +class Foo { + static foo() {} + foo(): void; + foo() {} +} + ", + "diagnostics": [ + { + "message": "Member foo should be declared before all public static method definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 11, + "line": 5, + }, + "start": { + "column": 3, + "line": 5, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 1, + "fileCount": 1, + "ruleCount": 1, +} +`; From 672b3fc551bf8721afc7d413e3d7ed2308fb9197 Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Mon, 9 Feb 2026 02:48:08 +0000 Subject: [PATCH 3/5] test: enable member-ordering variant suites Co-authored-by: Zack Jackson --- packages/rslint-test-tools/rstest.config.mts | 10 +- ...ically-case-insensitive-order.test.ts.snap | 478 +++++ ...ordering-alphabetically-order.test.ts.snap | 1569 +++++++++++++++++ ...atural-case-insensitive-order.test.ts.snap | 107 ++ ...member-ordering-natural-order.test.ts.snap | 137 ++ ...mber-ordering-optionalMembers.test.ts.snap | 262 +++ ...habetically-case-insensitive-order.test.ts | 2 +- ...mber-ordering-alphabetically-order.test.ts | 2 +- ...ing-natural-case-insensitive-order.test.ts | 2 +- .../member-ordering-natural-order.test.ts | 2 +- .../member-ordering-optionalMembers.test.ts | 2 +- 11 files changed, 2563 insertions(+), 10 deletions(-) create mode 100644 packages/rslint-test-tools/tests/typescript-eslint/rules/member-ordering/__snapshots__/member-ordering-alphabetically-case-insensitive-order.test.ts.snap create mode 100644 packages/rslint-test-tools/tests/typescript-eslint/rules/member-ordering/__snapshots__/member-ordering-alphabetically-order.test.ts.snap create mode 100644 packages/rslint-test-tools/tests/typescript-eslint/rules/member-ordering/__snapshots__/member-ordering-natural-case-insensitive-order.test.ts.snap create mode 100644 packages/rslint-test-tools/tests/typescript-eslint/rules/member-ordering/__snapshots__/member-ordering-natural-order.test.ts.snap create mode 100644 packages/rslint-test-tools/tests/typescript-eslint/rules/member-ordering/__snapshots__/member-ordering-optionalMembers.test.ts.snap diff --git a/packages/rslint-test-tools/rstest.config.mts b/packages/rslint-test-tools/rstest.config.mts index 4109616ce..beabdcf7e 100644 --- a/packages/rslint-test-tools/rstest.config.mts +++ b/packages/rslint-test-tools/rstest.config.mts @@ -38,11 +38,11 @@ export default defineConfig({ // './tests/typescript-eslint/rules/init-declarations.test.ts', // './tests/typescript-eslint/rules/max-params.test.ts', './tests/typescript-eslint/rules/member-ordering.test.ts', - // './tests/typescript-eslint/rules/member-ordering/member-ordering-alphabetically-case-insensitive-order.test.ts', - // './tests/typescript-eslint/rules/member-ordering/member-ordering-alphabetically-order.test.ts', - // './tests/typescript-eslint/rules/member-ordering/member-ordering-natural-case-insensitive-order.test.ts', - // './tests/typescript-eslint/rules/member-ordering/member-ordering-natural-order.test.ts', - // './tests/typescript-eslint/rules/member-ordering/member-ordering-optionalMembers.test.ts', + './tests/typescript-eslint/rules/member-ordering/member-ordering-alphabetically-case-insensitive-order.test.ts', + './tests/typescript-eslint/rules/member-ordering/member-ordering-alphabetically-order.test.ts', + './tests/typescript-eslint/rules/member-ordering/member-ordering-natural-case-insensitive-order.test.ts', + './tests/typescript-eslint/rules/member-ordering/member-ordering-natural-order.test.ts', + './tests/typescript-eslint/rules/member-ordering/member-ordering-optionalMembers.test.ts', // './tests/typescript-eslint/rules/method-signature-style.test.ts', // './tests/typescript-eslint/rules/naming-convention/cases/accessor.test.ts', // './tests/typescript-eslint/rules/naming-convention/cases/autoAccessor.test.ts', diff --git a/packages/rslint-test-tools/tests/typescript-eslint/rules/member-ordering/__snapshots__/member-ordering-alphabetically-case-insensitive-order.test.ts.snap b/packages/rslint-test-tools/tests/typescript-eslint/rules/member-ordering/__snapshots__/member-ordering-alphabetically-case-insensitive-order.test.ts.snap new file mode 100644 index 000000000..6cd0b50e3 --- /dev/null +++ b/packages/rslint-test-tools/tests/typescript-eslint/rules/member-ordering/__snapshots__/member-ordering-alphabetically-case-insensitive-order.test.ts.snap @@ -0,0 +1,478 @@ +// Rstest Snapshot v1 + +exports[`member-ordering > invalid 1`] = ` +{ + "code": " +interface Foo { + c: string; + B: string; + a: string; +} + ", + "diagnostics": [ + { + "message": "Member B should be declared before member c.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 13, + "line": 4, + }, + "start": { + "column": 3, + "line": 4, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member a should be declared before member B.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 13, + "line": 5, + }, + "start": { + "column": 3, + "line": 5, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 2, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 2`] = ` +{ + "code": " +interface Foo { + B: b; + a: b; +} + ", + "diagnostics": [ + { + "message": "Member a should be declared before member B.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 8, + "line": 4, + }, + "start": { + "column": 3, + "line": 4, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 1, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 3`] = ` +{ + "code": " +type Foo = { + B: b; + a: b; +}; + ", + "diagnostics": [ + { + "message": "Member a should be declared before member B.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 8, + "line": 4, + }, + "start": { + "column": 3, + "line": 4, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 1, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 4`] = ` +{ + "code": " +class Foo { + public static B: string; + public static a: string; +} + ", + "diagnostics": [ + { + "message": "Member a should be declared before member B.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 27, + "line": 4, + }, + "start": { + "column": 3, + "line": 4, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 1, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 5`] = ` +{ + "code": " +const foo = class Foo { + public static B: string; + public static a: string; +}; + ", + "diagnostics": [ + { + "message": "Member a should be declared before member B.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 27, + "line": 4, + }, + "start": { + "column": 3, + "line": 4, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 1, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 6`] = ` +{ + "code": " +interface Foo { + [a: string]: number; + + a: x; + B: x; + c: x; + + c(): void; + B(): void; + a(): void; + + (): Baz; + + new (): Bar; +} + ", + "diagnostics": [ + { + "message": "Member B should be declared before member c.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 13, + "line": 10, + }, + "start": { + "column": 3, + "line": 10, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member a should be declared before member B.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 13, + "line": 11, + }, + "start": { + "column": 3, + "line": 11, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member call should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 11, + "line": 13, + }, + "start": { + "column": 3, + "line": 13, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member new should be declared before all method definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 15, + "line": 15, + }, + "start": { + "column": 3, + "line": 15, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 4, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 7`] = ` +{ + "code": " +type Foo = { + [a: string]: number; + + a: x; + B: x; + c: x; + + c(): void; + B(): void; + a(): void; + + (): Baz; + + new (): Bar; +}; + ", + "diagnostics": [ + { + "message": "Member B should be declared before member c.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 13, + "line": 10, + }, + "start": { + "column": 3, + "line": 10, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member a should be declared before member B.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 13, + "line": 11, + }, + "start": { + "column": 3, + "line": 11, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member call should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 11, + "line": 13, + }, + "start": { + "column": 3, + "line": 13, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member new should be declared before all method definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 15, + "line": 15, + }, + "start": { + "column": 3, + "line": 15, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 4, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 8`] = ` +{ + "code": " +class Foo { + public static c: string = ''; + public static B: string = ''; + public static a: string; + + constructor() {} + + public d: string = ''; +} + ", + "diagnostics": [ + { + "message": "Member B should be declared before member c.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 32, + "line": 4, + }, + "start": { + "column": 3, + "line": 4, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member a should be declared before member B.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 27, + "line": 5, + }, + "start": { + "column": 3, + "line": 5, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member d should be declared before all public constructor definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 25, + "line": 9, + }, + "start": { + "column": 3, + "line": 9, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 3, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 9`] = ` +{ + "code": " +const foo = class Foo { + public static c: string = ''; + public static B: string = ''; + public static a: string; + + constructor() {} + + public d: string = ''; +}; + ", + "diagnostics": [ + { + "message": "Member B should be declared before member c.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 32, + "line": 4, + }, + "start": { + "column": 3, + "line": 4, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member a should be declared before member B.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 27, + "line": 5, + }, + "start": { + "column": 3, + "line": 5, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member d should be declared before all public constructor definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 25, + "line": 9, + }, + "start": { + "column": 3, + "line": 9, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 3, + "fileCount": 1, + "ruleCount": 1, +} +`; diff --git a/packages/rslint-test-tools/tests/typescript-eslint/rules/member-ordering/__snapshots__/member-ordering-alphabetically-order.test.ts.snap b/packages/rslint-test-tools/tests/typescript-eslint/rules/member-ordering/__snapshots__/member-ordering-alphabetically-order.test.ts.snap new file mode 100644 index 000000000..6159281e1 --- /dev/null +++ b/packages/rslint-test-tools/tests/typescript-eslint/rules/member-ordering/__snapshots__/member-ordering-alphabetically-order.test.ts.snap @@ -0,0 +1,1569 @@ +// Rstest Snapshot v1 + +exports[`member-ordering > invalid 1`] = ` +{ + "code": " +interface Foo { + b(): void; + a: b; + [a: string]: number; + new (): Bar; + (): Baz; +} + ", + "diagnostics": [ + { + "message": "Member a should be declared before member b.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 8, + "line": 4, + }, + "start": { + "column": 3, + "line": 4, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member call should be declared before member new.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 11, + "line": 7, + }, + "start": { + "column": 3, + "line": 7, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 2, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 2`] = ` +{ + "code": " +interface Foo { + 'b.d': Foo; + 'b.c': Foo; + a: Foo; +} + ", + "diagnostics": [ + { + "message": "Member b.c should be declared before member b.d.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 14, + "line": 4, + }, + "start": { + "column": 3, + "line": 4, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member a should be declared before member b.c.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 10, + "line": 5, + }, + "start": { + "column": 3, + "line": 5, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 2, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 3`] = ` +{ + "code": " +interface Foo { + c: string; + b: string; + a: string; +} + ", + "diagnostics": [ + { + "message": "Member b should be declared before member c.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 13, + "line": 4, + }, + "start": { + "column": 3, + "line": 4, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member a should be declared before member b.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 13, + "line": 5, + }, + "start": { + "column": 3, + "line": 5, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 2, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 4`] = ` +{ + "code": " +type Foo = { + b(): void; + a: b; + [a: string]: number; + new (): Bar; + (): Baz; +}; + ", + "diagnostics": [ + { + "message": "Member a should be declared before member b.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 8, + "line": 4, + }, + "start": { + "column": 3, + "line": 4, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member call should be declared before member new.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 11, + "line": 7, + }, + "start": { + "column": 3, + "line": 7, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 2, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 5`] = ` +{ + "code": " +type Foo = { + 'b.d': Foo; + 'b.c': Foo; + a: Foo; +}; + ", + "diagnostics": [ + { + "message": "Member b.c should be declared before member b.d.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 14, + "line": 4, + }, + "start": { + "column": 3, + "line": 4, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member a should be declared before member b.c.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 10, + "line": 5, + }, + "start": { + "column": 3, + "line": 5, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 2, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 6`] = ` +{ + "code": " +type Foo = { + c: string; + b: string; + a: string; +}; + ", + "diagnostics": [ + { + "message": "Member b should be declared before member c.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 13, + "line": 4, + }, + "start": { + "column": 3, + "line": 4, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member a should be declared before member b.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 13, + "line": 5, + }, + "start": { + "column": 3, + "line": 5, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 2, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 7`] = ` +{ + "code": " +class Foo { + protected static b: string = ''; + public static a: string; + private static c: string = ''; + constructor() {} + public d: string = ''; + protected e: string = ''; + private f: string = ''; +} + ", + "diagnostics": [ + { + "message": "Member a should be declared before member b.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 27, + "line": 4, + }, + "start": { + "column": 3, + "line": 4, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 1, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 8`] = ` +{ + "code": " +class Foo { + public static c: string; + public static b: string; + public static a: string; +} + ", + "diagnostics": [ + { + "message": "Member b should be declared before member c.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 27, + "line": 4, + }, + "start": { + "column": 3, + "line": 4, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member a should be declared before member b.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 27, + "line": 5, + }, + "start": { + "column": 3, + "line": 5, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 2, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 9`] = ` +{ + "code": " +const foo = class Foo { + protected static b: string = ''; + public static a: string; + private static c: string = ''; + constructor() {} + public d: string = ''; + protected e: string = ''; + private f: string = ''; +}; + ", + "diagnostics": [ + { + "message": "Member a should be declared before member b.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 27, + "line": 4, + }, + "start": { + "column": 3, + "line": 4, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 1, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 10`] = ` +{ + "code": " +const foo = class Foo { + public static c: string; + public static b: string; + public static a: string; +}; + ", + "diagnostics": [ + { + "message": "Member b should be declared before member c.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 27, + "line": 4, + }, + "start": { + "column": 3, + "line": 4, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member a should be declared before member b.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 27, + "line": 5, + }, + "start": { + "column": 3, + "line": 5, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 2, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 11`] = ` +{ + "code": " +class Foo { + protected static b: string = ''; + public static a: string; + private static c: string = ''; + constructor() {} + public d: string = ''; + protected e: string = ''; + private f: string = ''; +} + ", + "diagnostics": [ + { + "message": "Member a should be declared before member b.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 27, + "line": 4, + }, + "start": { + "column": 3, + "line": 4, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 1, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 12`] = ` +{ + "code": " +class Foo { + public static c: string; + public static b: string; + public static a: string; +} + ", + "diagnostics": [ + { + "message": "Member b should be declared before member c.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 27, + "line": 4, + }, + "start": { + "column": 3, + "line": 4, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member a should be declared before member b.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 27, + "line": 5, + }, + "start": { + "column": 3, + "line": 5, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 2, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 13`] = ` +{ + "code": " +const foo = class Foo { + protected static b: string = ''; + public static a: string; + private static c: string = ''; + constructor() {} + public d: string = ''; + protected e: string = ''; + private f: string = ''; +}; + ", + "diagnostics": [ + { + "message": "Member a should be declared before member b.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 27, + "line": 4, + }, + "start": { + "column": 3, + "line": 4, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 1, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 14`] = ` +{ + "code": " +const foo = class Foo { + public static c: string; + public static b: string; + public static a: string; +}; + ", + "diagnostics": [ + { + "message": "Member b should be declared before member c.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 27, + "line": 4, + }, + "start": { + "column": 3, + "line": 4, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member a should be declared before member b.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 27, + "line": 5, + }, + "start": { + "column": 3, + "line": 5, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 2, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 15`] = ` +{ + "code": " +interface Foo { + b(): void; + a: b; + [a: string]: number; + new (): Bar; + (): Baz; +} + ", + "diagnostics": [ + { + "message": "Member a should be declared before member b.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 8, + "line": 4, + }, + "start": { + "column": 3, + "line": 4, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member call should be declared before member new.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 11, + "line": 7, + }, + "start": { + "column": 3, + "line": 7, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 2, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 16`] = ` +{ + "code": " +interface Foo { + c: string; + b: string; + a: string; +} + ", + "diagnostics": [ + { + "message": "Member b should be declared before member c.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 13, + "line": 4, + }, + "start": { + "column": 3, + "line": 4, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member a should be declared before member b.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 13, + "line": 5, + }, + "start": { + "column": 3, + "line": 5, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 2, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 17`] = ` +{ + "code": " +type Foo = { + b(): void; + a: b; + [a: string]: number; + new (): Bar; + (): Baz; +}; + ", + "diagnostics": [ + { + "message": "Member a should be declared before member b.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 8, + "line": 4, + }, + "start": { + "column": 3, + "line": 4, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member call should be declared before member new.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 11, + "line": 7, + }, + "start": { + "column": 3, + "line": 7, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 2, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 18`] = ` +{ + "code": " +type Foo = { + c: string; + b: string; + a: string; +}; + ", + "diagnostics": [ + { + "message": "Member b should be declared before member c.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 13, + "line": 4, + }, + "start": { + "column": 3, + "line": 4, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member a should be declared before member b.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 13, + "line": 5, + }, + "start": { + "column": 3, + "line": 5, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 2, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 19`] = ` +{ + "code": " +class FooTestGetter { + public static a: string; + protected static b: string = ''; + private static c: string = ''; + + public d: string = ''; + protected e: string = ''; + private f: string = ''; + + get h() {} + + set g() {} + + constructor() {} +} + ", + "diagnostics": [ + { + "message": "Member constructor should be declared before all public instance get definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 19, + "line": 15, + }, + "start": { + "column": 3, + "line": 15, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 1, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 20`] = ` +{ + "code": " +class Foo { + @Bar + get a() {} + + get b() {} + + @Bar + set c() {} + + set d() {} +} + ", + "diagnostics": [ + { + "message": "Member b should be declared before all decorated get definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 13, + "line": 6, + }, + "start": { + "column": 3, + "line": 6, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member d should be declared before all decorated set definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 13, + "line": 11, + }, + "start": { + "column": 3, + "line": 11, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 2, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 21`] = ` +{ + "code": " +class FooTestGetter { + public static a: string; + protected static b: string = ''; + private static c: string = ''; + + public d: string = ''; + protected e: string = ''; + private f: string = ''; + + set g() {} + + constructor() {} + + get h() {} +} + ", + "diagnostics": [ + { + "message": "Member constructor should be declared before all public instance set definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 19, + "line": 13, + }, + "start": { + "column": 3, + "line": 13, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member h should be declared before all public instance set definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 13, + "line": 15, + }, + "start": { + "column": 3, + "line": 15, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 2, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 22`] = ` +{ + "code": " +const foo = class Foo { + public static c: string = ''; + public static b: string = ''; + public static a: string; + + constructor() {} + + public d: string = ''; +}; + ", + "diagnostics": [ + { + "message": "Member b should be declared before member c.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 32, + "line": 4, + }, + "start": { + "column": 3, + "line": 4, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member a should be declared before member b.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 27, + "line": 5, + }, + "start": { + "column": 3, + "line": 5, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member d should be declared before all public constructor definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 25, + "line": 9, + }, + "start": { + "column": 3, + "line": 9, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 3, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 23`] = ` +{ + "code": " +class Foo { + @Dec() a1: string; + @Dec() + a3: string; + @Dec() + a2: string; + + constructor() {} + + b1: string; + b2: string; + + public c(): void; + @Dec() d(): void {} +} + ", + "diagnostics": [ + { + "message": "Member a2 should be declared before member a3.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 14, + "line": 7, + }, + "start": { + "column": 3, + "line": 6, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member b1 should be declared before all constructor definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 14, + "line": 11, + }, + "start": { + "column": 3, + "line": 11, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member b2 should be declared before all constructor definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 14, + "line": 12, + }, + "start": { + "column": 3, + "line": 12, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 3, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 24`] = ` +{ + "code": " +class Foo { + public static c: string = ''; + public static b: string = ''; + public static a: string; + + constructor() {} + + public d: string = ''; +} + ", + "diagnostics": [ + { + "message": "Member b should be declared before member c.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 32, + "line": 4, + }, + "start": { + "column": 3, + "line": 4, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member a should be declared before member b.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 27, + "line": 5, + }, + "start": { + "column": 3, + "line": 5, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member d should be declared before all public constructor definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 25, + "line": 9, + }, + "start": { + "column": 3, + "line": 9, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 3, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 25`] = ` +{ + "code": " +const foo = class Foo { + public static c: string = ''; + public static b: string = ''; + public static a: string; + + constructor() {} + + public d: string = ''; +}; + ", + "diagnostics": [ + { + "message": "Member b should be declared before member c.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 32, + "line": 4, + }, + "start": { + "column": 3, + "line": 4, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member a should be declared before member b.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 27, + "line": 5, + }, + "start": { + "column": 3, + "line": 5, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member d should be declared before all public constructor definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 25, + "line": 9, + }, + "start": { + "column": 3, + "line": 9, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 3, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 26`] = ` +{ + "code": " +interface Foo { + [a: string]: number; + + a: x; + b: x; + c: x; + + c(): void; + b(): void; + a(): void; + + (): Baz; + + new (): Bar; +} + ", + "diagnostics": [ + { + "message": "Member b should be declared before member c.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 13, + "line": 10, + }, + "start": { + "column": 3, + "line": 10, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member a should be declared before member b.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 13, + "line": 11, + }, + "start": { + "column": 3, + "line": 11, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member call should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 11, + "line": 13, + }, + "start": { + "column": 3, + "line": 13, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member new should be declared before all method definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 15, + "line": 15, + }, + "start": { + "column": 3, + "line": 15, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 4, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 27`] = ` +{ + "code": " +type Foo = { + [a: string]: number; + + a: x; + b: x; + c: x; + + c(): void; + b(): void; + a(): void; + + (): Baz; + + new (): Bar; +}; + ", + "diagnostics": [ + { + "message": "Member b should be declared before member c.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 13, + "line": 10, + }, + "start": { + "column": 3, + "line": 10, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member a should be declared before member b.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 13, + "line": 11, + }, + "start": { + "column": 3, + "line": 11, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member call should be declared before all field definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 11, + "line": 13, + }, + "start": { + "column": 3, + "line": 13, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member new should be declared before all method definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 15, + "line": 15, + }, + "start": { + "column": 3, + "line": 15, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 4, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 28`] = ` +{ + "code": " +class Foo { + #c = 3; + #b = 2; + #a = 1; +} + ", + "diagnostics": [ + { + "message": "Member #b should be declared before member #c.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 10, + "line": 4, + }, + "start": { + "column": 3, + "line": 4, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member #a should be declared before member #b.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 10, + "line": 5, + }, + "start": { + "column": 3, + "line": 5, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 2, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 29`] = ` +{ + "code": " +class Foo { + @Dec() accessor b; + @Dec() accessor a; + + accessor d; + accessor c; + + abstract accessor f; + abstract accessor e; +} + ", + "diagnostics": [ + { + "message": "Member a should be declared before member b.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 21, + "line": 4, + }, + "start": { + "column": 3, + "line": 4, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member c should be declared before member d.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 14, + "line": 7, + }, + "start": { + "column": 3, + "line": 7, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member e should be declared before member f.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 23, + "line": 10, + }, + "start": { + "column": 3, + "line": 10, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 3, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 30`] = ` +{ + "code": " +class Foo { + accessor a; + abstract accessor b; + accessor c; + @Dec() accessor d; +} + ", + "diagnostics": [ + { + "message": "Member c should be declared before all abstract accessor definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 14, + "line": 5, + }, + "start": { + "column": 3, + "line": 5, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member d should be declared before all accessor definitions.", + "messageId": "incorrectGroupOrder", + "range": { + "end": { + "column": 21, + "line": 6, + }, + "start": { + "column": 3, + "line": 6, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 2, + "fileCount": 1, + "ruleCount": 1, +} +`; diff --git a/packages/rslint-test-tools/tests/typescript-eslint/rules/member-ordering/__snapshots__/member-ordering-natural-case-insensitive-order.test.ts.snap b/packages/rslint-test-tools/tests/typescript-eslint/rules/member-ordering/__snapshots__/member-ordering-natural-case-insensitive-order.test.ts.snap new file mode 100644 index 000000000..14931166a --- /dev/null +++ b/packages/rslint-test-tools/tests/typescript-eslint/rules/member-ordering/__snapshots__/member-ordering-natural-case-insensitive-order.test.ts.snap @@ -0,0 +1,107 @@ +// Rstest Snapshot v1 + +exports[`member-ordering > invalid 1`] = ` +{ + "code": " +interface Example { + 1: number; + 10: number; + 5: number; +} + ", + "diagnostics": [ + { + "message": "Member 5 should be declared before member 10.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 13, + "line": 5, + }, + "start": { + "column": 3, + "line": 5, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 1, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 2`] = ` +{ + "code": " +interface Example { + new (): unknown; + + a1(): void; + a10(): void; + a5(): void; + B5(): void; + B10(): void; + B1(): void; + + a5: number; + a10: number; + B1: number; + a1: number; + B5: number; + B10: number; +} + ", + "diagnostics": [ + { + "message": "Member a5 should be declared before member a10.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 14, + "line": 7, + }, + "start": { + "column": 3, + "line": 7, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member B1 should be declared before member B10.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 14, + "line": 10, + }, + "start": { + "column": 3, + "line": 10, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member a1 should be declared before member B1.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 14, + "line": 15, + }, + "start": { + "column": 3, + "line": 15, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 3, + "fileCount": 1, + "ruleCount": 1, +} +`; diff --git a/packages/rslint-test-tools/tests/typescript-eslint/rules/member-ordering/__snapshots__/member-ordering-natural-order.test.ts.snap b/packages/rslint-test-tools/tests/typescript-eslint/rules/member-ordering/__snapshots__/member-ordering-natural-order.test.ts.snap new file mode 100644 index 000000000..97b2675cc --- /dev/null +++ b/packages/rslint-test-tools/tests/typescript-eslint/rules/member-ordering/__snapshots__/member-ordering-natural-order.test.ts.snap @@ -0,0 +1,137 @@ +// Rstest Snapshot v1 + +exports[`member-ordering > invalid 1`] = ` +{ + "code": " +interface Example { + 1: number; + 10: number; + 5: number; +} + ", + "diagnostics": [ + { + "message": "Member 5 should be declared before member 10.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 13, + "line": 5, + }, + "start": { + "column": 3, + "line": 5, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 1, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 2`] = ` +{ + "code": " +interface Example { + new (): unknown; + + a1(): void; + a10(): void; + a5(): void; + B5(): void; + B10(): void; + B1(): void; + + a5: number; + a10: number; + B1: number; + a1: number; + B5: number; + B10: number; +} + ", + "diagnostics": [ + { + "message": "Member a5 should be declared before member a10.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 14, + "line": 7, + }, + "start": { + "column": 3, + "line": 7, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member B5 should be declared before member a5.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 14, + "line": 8, + }, + "start": { + "column": 3, + "line": 8, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member B1 should be declared before member B10.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 14, + "line": 10, + }, + "start": { + "column": 3, + "line": 10, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member B1 should be declared before member a10.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 14, + "line": 14, + }, + "start": { + "column": 3, + "line": 14, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + { + "message": "Member B5 should be declared before member a1.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 14, + "line": 16, + }, + "start": { + "column": 3, + "line": 16, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 5, + "fileCount": 1, + "ruleCount": 1, +} +`; diff --git a/packages/rslint-test-tools/tests/typescript-eslint/rules/member-ordering/__snapshots__/member-ordering-optionalMembers.test.ts.snap b/packages/rslint-test-tools/tests/typescript-eslint/rules/member-ordering/__snapshots__/member-ordering-optionalMembers.test.ts.snap new file mode 100644 index 000000000..a5bc316b3 --- /dev/null +++ b/packages/rslint-test-tools/tests/typescript-eslint/rules/member-ordering/__snapshots__/member-ordering-optionalMembers.test.ts.snap @@ -0,0 +1,262 @@ +// Rstest Snapshot v1 + +exports[`member-ordering > invalid 1`] = ` +{ + "code": " +interface X { + m: string; + d?: string; + b?: string; +} + ", + "diagnostics": [ + { + "message": "Member b should be declared before member d.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 14, + "line": 5, + }, + "start": { + "column": 3, + "line": 5, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 1, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 2`] = ` +{ + "code": " +interface X { + a: string; + b?: string; + c: string; +} + ", + "diagnostics": [ + { + "message": "Member b should be declared after all required members.", + "messageId": "incorrectRequiredMembersOrder", + "range": { + "end": { + "column": 14, + "line": 4, + }, + "start": { + "column": 3, + "line": 4, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 1, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 3`] = ` +{ + "code": " +class X { + a?: string; + static {} + b?: string; +} + ", + "diagnostics": [ + { + "message": "Member a should be declared after all required members.", + "messageId": "incorrectRequiredMembersOrder", + "range": { + "end": { + "column": 14, + "line": 3, + }, + "start": { + "column": 3, + "line": 3, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 1, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 4`] = ` +{ + "code": " +class X { + b: string; + a: string; +} + ", + "diagnostics": [ + { + "message": "Member a should be declared before member b.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 13, + "line": 4, + }, + "start": { + "column": 3, + "line": 4, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 1, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 5`] = ` +{ + "code": " +interface X { + d?: string; + b?: string; + m: string; +} + ", + "diagnostics": [ + { + "message": "Member b should be declared before member d.", + "messageId": "incorrectOrder", + "range": { + "end": { + "column": 14, + "line": 4, + }, + "start": { + "column": 3, + "line": 4, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 1, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 6`] = ` +{ + "code": " +interface X { + a?: string; + b: string; + c?: string; +} + ", + "diagnostics": [ + { + "message": "Member b should be declared after all optional members.", + "messageId": "incorrectRequiredMembersOrder", + "range": { + "end": { + "column": 13, + "line": 4, + }, + "start": { + "column": 3, + "line": 4, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 1, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 7`] = ` +{ + "code": " +class Test { + a?: string; + b?: string; + f: string; + c?: string; + d?: string; + g: string; + h: string; +} + ", + "diagnostics": [ + { + "message": "Member f should be declared after all optional members.", + "messageId": "incorrectRequiredMembersOrder", + "range": { + "end": { + "column": 13, + "line": 5, + }, + "start": { + "column": 3, + "line": 5, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 1, + "fileCount": 1, + "ruleCount": 1, +} +`; + +exports[`member-ordering > invalid 8`] = ` +{ + "code": " +class Test { + a: string; + b: string; + f?: string; + c?: string; + d?: string; +} + ", + "diagnostics": [ + { + "message": "Member a should be declared after all optional members.", + "messageId": "incorrectRequiredMembersOrder", + "range": { + "end": { + "column": 13, + "line": 3, + }, + "start": { + "column": 3, + "line": 3, + }, + }, + "ruleName": "@typescript-eslint/member-ordering", + }, + ], + "errorCount": 1, + "fileCount": 1, + "ruleCount": 1, +} +`; diff --git a/packages/rslint-test-tools/tests/typescript-eslint/rules/member-ordering/member-ordering-alphabetically-case-insensitive-order.test.ts b/packages/rslint-test-tools/tests/typescript-eslint/rules/member-ordering/member-ordering-alphabetically-case-insensitive-order.test.ts index b20e41d81..c1129df7d 100644 --- a/packages/rslint-test-tools/tests/typescript-eslint/rules/member-ordering/member-ordering-alphabetically-case-insensitive-order.test.ts +++ b/packages/rslint-test-tools/tests/typescript-eslint/rules/member-ordering/member-ordering-alphabetically-case-insensitive-order.test.ts @@ -723,7 +723,7 @@ class Foo { ], }; -ruleTester.run('member-ordering-alphabetically-case-insensitive-order', { +ruleTester.run('member-ordering', { invalid: [ ...sortedCiWithoutGrouping.invalid, ...sortedCiWithGrouping.invalid, diff --git a/packages/rslint-test-tools/tests/typescript-eslint/rules/member-ordering/member-ordering-alphabetically-order.test.ts b/packages/rslint-test-tools/tests/typescript-eslint/rules/member-ordering/member-ordering-alphabetically-order.test.ts index 1f158a8b1..3a1c94048 100644 --- a/packages/rslint-test-tools/tests/typescript-eslint/rules/member-ordering/member-ordering-alphabetically-order.test.ts +++ b/packages/rslint-test-tools/tests/typescript-eslint/rules/member-ordering/member-ordering-alphabetically-order.test.ts @@ -2728,7 +2728,7 @@ const sortedWithGrouping: RunTests = { ], }; -ruleTester.run('member-ordering-alphabetically-order', { +ruleTester.run('member-ordering', { invalid: [...sortedWithoutGrouping.invalid, ...sortedWithGrouping.invalid], valid: [...sortedWithoutGrouping.valid, ...sortedWithGrouping.valid], }); diff --git a/packages/rslint-test-tools/tests/typescript-eslint/rules/member-ordering/member-ordering-natural-case-insensitive-order.test.ts b/packages/rslint-test-tools/tests/typescript-eslint/rules/member-ordering/member-ordering-natural-case-insensitive-order.test.ts index 5fff921b6..1bd0e1365 100644 --- a/packages/rslint-test-tools/tests/typescript-eslint/rules/member-ordering/member-ordering-natural-case-insensitive-order.test.ts +++ b/packages/rslint-test-tools/tests/typescript-eslint/rules/member-ordering/member-ordering-natural-case-insensitive-order.test.ts @@ -4,7 +4,7 @@ import { RuleTester } from '@typescript-eslint/rule-tester'; const ruleTester = new RuleTester(); -ruleTester.run('member-ordering-natural-order', { +ruleTester.run('member-ordering', { invalid: [ { code: ` diff --git a/packages/rslint-test-tools/tests/typescript-eslint/rules/member-ordering/member-ordering-natural-order.test.ts b/packages/rslint-test-tools/tests/typescript-eslint/rules/member-ordering/member-ordering-natural-order.test.ts index 61ab3e3a1..52a81b1af 100644 --- a/packages/rslint-test-tools/tests/typescript-eslint/rules/member-ordering/member-ordering-natural-order.test.ts +++ b/packages/rslint-test-tools/tests/typescript-eslint/rules/member-ordering/member-ordering-natural-order.test.ts @@ -4,7 +4,7 @@ import { RuleTester } from '@typescript-eslint/rule-tester'; const ruleTester = new RuleTester(); -ruleTester.run('member-ordering-natural-order', { +ruleTester.run('member-ordering', { invalid: [ { code: ` diff --git a/packages/rslint-test-tools/tests/typescript-eslint/rules/member-ordering/member-ordering-optionalMembers.test.ts b/packages/rslint-test-tools/tests/typescript-eslint/rules/member-ordering/member-ordering-optionalMembers.test.ts index 1f0baddbd..40bb1b0d8 100644 --- a/packages/rslint-test-tools/tests/typescript-eslint/rules/member-ordering/member-ordering-optionalMembers.test.ts +++ b/packages/rslint-test-tools/tests/typescript-eslint/rules/member-ordering/member-ordering-optionalMembers.test.ts @@ -488,4 +488,4 @@ class Test { ], }; -ruleTester.run('member-ordering-required', grouped); +ruleTester.run('member-ordering', grouped); From 9c6192518d896313f73baa24dcd2f94999c401cf Mon Sep 17 00:00:00 2001 From: ScriptedAlchemy Date: Mon, 9 Feb 2026 05:46:25 -0800 Subject: [PATCH 4/5] fix: adjust member-ordering linting Use a tagged switch to satisfy staticcheck and disable the rule in rslint.json to prevent dogfooding lint errors. Co-authored-by: Cursor --- .../typescript/rules/member_ordering/member_ordering.go | 5 +++-- rslint.json | 3 ++- 2 files changed, 5 insertions(+), 3 deletions(-) diff --git a/internal/plugins/typescript/rules/member_ordering/member_ordering.go b/internal/plugins/typescript/rules/member_ordering/member_ordering.go index 25d85dce5..84c8468bc 100644 --- a/internal/plugins/typescript/rules/member_ordering/member_ordering.go +++ b/internal/plugins/typescript/rules/member_ordering/member_ordering.go @@ -694,9 +694,10 @@ func getRank(sourceFile *ast.SourceFile, node *ast.Node, orderConfig []memberTyp } memberGroups = append(memberGroups, nodeType) - if nodeType == "readonly-signature" { + switch nodeType { + case "readonly-signature": memberGroups = append(memberGroups, "signature") - } else if nodeType == "readonly-field" { + case "readonly-field": memberGroups = append(memberGroups, "field") } diff --git a/rslint.json b/rslint.json index 46461fc17..79b10dd0e 100644 --- a/rslint.json +++ b/rslint.json @@ -55,7 +55,8 @@ "@typescript-eslint/no-unused-vars": "warn", "@typescript-eslint/require-await": "warn", "@typescript-eslint/prefer-readonly": "warn", - "@typescript-eslint/no-non-null-assertion": "warn" + "@typescript-eslint/no-non-null-assertion": "warn", + "@typescript-eslint/member-ordering": "off" }, "plugins": ["@typescript-eslint"] } From 569521f39d3345a3343c9183289100231e6bdd7a Mon Sep 17 00:00:00 2001 From: ScriptedAlchemy Date: Wed, 25 Feb 2026 12:56:41 -0800 Subject: [PATCH 5/5] fix(typescript/member-ordering): handle missed alpha-ordering cases --- .../rules/member_ordering/member_ordering.go | 31 ++++++-------- .../member_ordering/member_ordering_test.go | 41 +++++++++++++++++++ 2 files changed, 54 insertions(+), 18 deletions(-) diff --git a/internal/plugins/typescript/rules/member_ordering/member_ordering.go b/internal/plugins/typescript/rules/member_ordering/member_ordering.go index 84c8468bc..f7f4e59bd 100644 --- a/internal/plugins/typescript/rules/member_ordering/member_ordering.go +++ b/internal/plugins/typescript/rules/member_ordering/member_ordering.go @@ -534,7 +534,7 @@ func naturalOutOfOrder(name string, previousName string, order string) bool { case orderNatural: return naturalCompare(name, previousName) != 1 case orderNaturalInsensitive: - return naturalCompare(strings.ToLower(name), strings.ToLower(previousName)) != 1 + return naturalCompare(strings.ToLower(name), strings.ToLower(previousName)) < 0 default: return false } @@ -572,7 +572,7 @@ func checkRequiredOrder(ctx rule.RuleContext, members []*ast.Node, optionalityOr func groupMembersByType(members []*ast.Node, memberTypes []memberTypeGroup, supportsModifiers bool, sourceFile *ast.SourceFile) [][]*ast.Node { grouped := make([][]*ast.Node, 0, 4) - if len(members) == 0 { + if len(members) < 2 { return grouped } @@ -581,25 +581,20 @@ func groupMembersByType(members []*ast.Node, memberTypes []memberTypeGroup, supp memberRanks[i] = getRank(sourceFile, member, memberTypes, supportsModifiers) } - previousRank := 0 - hasPrevious := false - - for i, member := range members { - if i == len(members)-1 { - return grouped - } - currentRank := memberRanks[i] - nextRank := memberRanks[i+1] - - if hasPrevious && currentRank == previousRank { - grouped[len(grouped)-1] = append(grouped[len(grouped)-1], member) - } else if currentRank == nextRank { - grouped = append(grouped, []*ast.Node{member}) - previousRank = currentRank - hasPrevious = true + start := 0 + for i := 1; i < len(members); i++ { + if memberRanks[i] != memberRanks[start] { + if i-start > 1 && memberRanks[start] != -1 { + grouped = append(grouped, members[start:i]) + } + start = i } } + if len(members)-start > 1 && memberRanks[start] != -1 { + grouped = append(grouped, members[start:]) + } + return grouped } diff --git a/internal/plugins/typescript/rules/member_ordering/member_ordering_test.go b/internal/plugins/typescript/rules/member_ordering/member_ordering_test.go index 36dfd6507..b8f189307 100644 --- a/internal/plugins/typescript/rules/member_ordering/member_ordering_test.go +++ b/internal/plugins/typescript/rules/member_ordering/member_ordering_test.go @@ -37,6 +37,20 @@ func TestMemberOrderingRule(t *testing.T) { }, }, }, + { + Code: `class Foo { + foo(): void {} + Foo(): void {} +}`, + Options: []interface{}{ + map[string]interface{}{ + "default": map[string]interface{}{ + "memberTypes": "never", + "order": "natural-case-insensitive", + }, + }, + }, + }, }, []rule_tester.InvalidTestCase{ { Code: `class Foo { @@ -157,5 +171,32 @@ func TestMemberOrderingRule(t *testing.T) { }, }, }, + { + Code: `class Foo { + b(): void {} + a(): void {} + field: string; +}`, + Options: []interface{}{ + map[string]interface{}{ + "default": map[string]interface{}{ + "memberTypes": []interface{}{"field", "method"}, + "order": "alphabetically", + }, + }, + }, + Errors: []rule_tester.InvalidTestCaseError{ + { + MessageId: "incorrectGroupOrder", + Line: 4, + Column: 3, + }, + { + MessageId: "incorrectOrder", + Line: 3, + Column: 3, + }, + }, + }, }) }