@ttsc/lint 0.14.0-dev.20260529.1 → 0.14.0

package/linthost/rules_ts_no_unnecessary_type_arguments.go

@@ -7,7 +7,7 @@
 package linthost
 
 import (
-	shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
 // noUnnecessaryTypeArguments visits the three syntactic positions that
@@ -27,63 +27,63 @@ import (
 type noUnnecessaryTypeArguments struct{}
 
 func (noUnnecessaryTypeArguments) Name() string {
-	return "typescript/no-unnecessary-type-arguments"
+  return "typescript/no-unnecessary-type-arguments"
 }
 func (noUnnecessaryTypeArguments) NeedsTypeChecker() bool {
-	return true
+  return true
 }
 func (noUnnecessaryTypeArguments) Visits() []shimast.Kind {
-	return []shimast.Kind{
-		shimast.KindTypeReference,
-		shimast.KindExpressionWithTypeArguments,
-		shimast.KindCallExpression,
-		shimast.KindNewExpression,
-	}
+  return []shimast.Kind{
+    shimast.KindTypeReference,
+    shimast.KindExpressionWithTypeArguments,
+    shimast.KindCallExpression,
+    shimast.KindNewExpression,
+  }
 }
 func (noUnnecessaryTypeArguments) Check(ctx *Context, node *shimast.Node) {
-	if ctx.Checker == nil {
-		return
-	}
-	args, nameNode := noUnnecessaryTypeArgumentsExtract(node)
-	if len(args) == 0 || nameNode == nil {
-		return
-	}
-	params := noUnnecessaryTypeArgumentsResolveParameters(ctx, nameNode)
-	if len(params) == 0 {
-		return
-	}
-	// Walk from the right: report contiguous trailing args that equal
-	// their declared defaults. Stop at the first mismatch — only the
-	// suffix is droppable.
-	for i := len(args) - 1; i >= 0; i-- {
-		if i >= len(params) {
-			continue
-		}
-		param := params[i]
-		if param == nil {
-			break
-		}
-		defaultNode := param.DefaultType
-		if defaultNode == nil {
-			break
-		}
-		argNode := args[i]
-		if argNode == nil {
-			break
-		}
-		argType := ctx.Checker.GetTypeFromTypeNode(argNode)
-		defaultType := ctx.Checker.GetTypeFromTypeNode(defaultNode)
-		if argType == nil || defaultType == nil {
-			break
-		}
-		if !ctx.Checker.IsTypeAssignableTo(argType, defaultType) {
-			break
-		}
-		if !ctx.Checker.IsTypeAssignableTo(defaultType, argType) {
-			break
-		}
-		ctx.Report(argNode, "This type argument equals the declared default — drop it.")
-	}
+  if ctx.Checker == nil {
+    return
+  }
+  args, nameNode := noUnnecessaryTypeArgumentsExtract(node)
+  if len(args) == 0 || nameNode == nil {
+    return
+  }
+  params := noUnnecessaryTypeArgumentsResolveParameters(ctx, nameNode)
+  if len(params) == 0 {
+    return
+  }
+  // Walk from the right: report contiguous trailing args that equal
+  // their declared defaults. Stop at the first mismatch — only the
+  // suffix is droppable.
+  for i := len(args) - 1; i >= 0; i-- {
+    if i >= len(params) {
+      continue
+    }
+    param := params[i]
+    if param == nil {
+      break
+    }
+    defaultNode := param.DefaultType
+    if defaultNode == nil {
+      break
+    }
+    argNode := args[i]
+    if argNode == nil {
+      break
+    }
+    argType := ctx.Checker.GetTypeFromTypeNode(argNode)
+    defaultType := ctx.Checker.GetTypeFromTypeNode(defaultNode)
+    if argType == nil || defaultType == nil {
+      break
+    }
+    if !ctx.Checker.IsTypeAssignableTo(argType, defaultType) {
+      break
+    }
+    if !ctx.Checker.IsTypeAssignableTo(defaultType, argType) {
+      break
+    }
+    ctx.Report(argNode, "This type argument equals the declared default — drop it.")
+  }
 }
 
 // noUnnecessaryTypeArgumentsExtract returns the explicit type-argument
@@ -92,33 +92,33 @@ func (noUnnecessaryTypeArguments) Check(ctx *Context, node *shimast.Node) {
 // explicit type arguments — the rule only fires on opt-in argument
 // lists.
 func noUnnecessaryTypeArgumentsExtract(node *shimast.Node) ([]*shimast.Node, *shimast.Node) {
-	switch node.Kind {
-	case shimast.KindTypeReference:
-		ref := node.AsTypeReferenceNode()
-		if ref == nil || ref.TypeArguments == nil {
-			return nil, nil
-		}
-		return ref.TypeArguments.Nodes, ref.TypeName
-	case shimast.KindExpressionWithTypeArguments:
-		ewta := node.AsExpressionWithTypeArguments()
-		if ewta == nil || ewta.TypeArguments == nil {
-			return nil, nil
-		}
-		return ewta.TypeArguments.Nodes, ewta.Expression
-	case shimast.KindCallExpression:
-		call := node.AsCallExpression()
-		if call == nil || call.TypeArguments == nil {
-			return nil, nil
-		}
-		return call.TypeArguments.Nodes, call.Expression
-	case shimast.KindNewExpression:
-		ne := node.AsNewExpression()
-		if ne == nil || ne.TypeArguments == nil {
-			return nil, nil
-		}
-		return ne.TypeArguments.Nodes, ne.Expression
-	}
-	return nil, nil
+  switch node.Kind {
+  case shimast.KindTypeReference:
+    ref := node.AsTypeReferenceNode()
+    if ref == nil || ref.TypeArguments == nil {
+      return nil, nil
+    }
+    return ref.TypeArguments.Nodes, ref.TypeName
+  case shimast.KindExpressionWithTypeArguments:
+    ewta := node.AsExpressionWithTypeArguments()
+    if ewta == nil || ewta.TypeArguments == nil {
+      return nil, nil
+    }
+    return ewta.TypeArguments.Nodes, ewta.Expression
+  case shimast.KindCallExpression:
+    call := node.AsCallExpression()
+    if call == nil || call.TypeArguments == nil {
+      return nil, nil
+    }
+    return call.TypeArguments.Nodes, call.Expression
+  case shimast.KindNewExpression:
+    ne := node.AsNewExpression()
+    if ne == nil || ne.TypeArguments == nil {
+      return nil, nil
+    }
+    return ne.TypeArguments.Nodes, ne.Expression
+  }
+  return nil, nil
 }
 
 // noUnnecessaryTypeArgumentsResolveParameters resolves `nameNode` to a
@@ -127,35 +127,35 @@ func noUnnecessaryTypeArgumentsExtract(node *shimast.Node) ([]*shimast.Node, *sh
 // resolve or no declaration carries a type-parameter list — the rule
 // then has nothing to compare against.
 func noUnnecessaryTypeArgumentsResolveParameters(ctx *Context, nameNode *shimast.Node) []*shimast.TypeParameterDeclaration {
-	if nameNode == nil {
-		return nil
-	}
-	target := nameNode
-	// For property accesses (`a.b.Foo<T>`) the symbol-bearing identifier
-	// is the rightmost name, not the dotted root.
-	if target.Kind == shimast.KindPropertyAccessExpression {
-		access := target.AsPropertyAccessExpression()
-		if access == nil || access.Name() == nil {
-			return nil
-		}
-		target = access.Name()
-	} else if target.Kind == shimast.KindQualifiedName {
-		qn := target.AsQualifiedName()
-		if qn == nil || qn.Right == nil {
-			return nil
-		}
-		target = qn.Right
-	}
-	symbol := ctx.Checker.GetSymbolAtLocation(target)
-	if symbol == nil {
-		return nil
-	}
-	for _, decl := range symbol.Declarations {
-		if list := noUnnecessaryTypeArgumentsParamList(decl); list != nil {
-			return list
-		}
-	}
-	return nil
+  if nameNode == nil {
+    return nil
+  }
+  target := nameNode
+  // For property accesses (`a.b.Foo<T>`) the symbol-bearing identifier
+  // is the rightmost name, not the dotted root.
+  if target.Kind == shimast.KindPropertyAccessExpression {
+    access := target.AsPropertyAccessExpression()
+    if access == nil || access.Name() == nil {
+      return nil
+    }
+    target = access.Name()
+  } else if target.Kind == shimast.KindQualifiedName {
+    qn := target.AsQualifiedName()
+    if qn == nil || qn.Right == nil {
+      return nil
+    }
+    target = qn.Right
+  }
+  symbol := ctx.Checker.GetSymbolAtLocation(target)
+  if symbol == nil {
+    return nil
+  }
+  for _, decl := range symbol.Declarations {
+    if list := noUnnecessaryTypeArgumentsParamList(decl); list != nil {
+      return list
+    }
+  }
+  return nil
 }
 
 // noUnnecessaryTypeArgumentsParamList returns the type-parameter list on
@@ -165,70 +165,70 @@ func noUnnecessaryTypeArgumentsResolveParameters(ctx *Context, nameNode *shimast
 // / alias declarations, and the method-like signatures that may appear
 // inside them.
 func noUnnecessaryTypeArgumentsParamList(decl *shimast.Node) []*shimast.TypeParameterDeclaration {
-	if decl == nil {
-		return nil
-	}
-	var list *shimast.TypeParameterList
-	switch decl.Kind {
-	case shimast.KindFunctionDeclaration:
-		if d := decl.AsFunctionDeclaration(); d != nil {
-			list = d.TypeParameters
-		}
-	case shimast.KindClassDeclaration:
-		if d := decl.AsClassDeclaration(); d != nil {
-			list = d.TypeParameters
-		}
-	case shimast.KindClassExpression:
-		if d := decl.AsClassExpression(); d != nil {
-			list = d.TypeParameters
-		}
-	case shimast.KindInterfaceDeclaration:
-		if d := decl.AsInterfaceDeclaration(); d != nil {
-			list = d.TypeParameters
-		}
-	case shimast.KindTypeAliasDeclaration:
-		if d := decl.AsTypeAliasDeclaration(); d != nil {
-			list = d.TypeParameters
-		}
-	case shimast.KindMethodDeclaration:
-		if d := decl.AsMethodDeclaration(); d != nil {
-			list = d.TypeParameters
-		}
-	case shimast.KindMethodSignature:
-		if d := decl.AsMethodSignatureDeclaration(); d != nil {
-			list = d.TypeParameters
-		}
-	case shimast.KindFunctionExpression:
-		if d := decl.AsFunctionExpression(); d != nil {
-			list = d.TypeParameters
-		}
-	case shimast.KindArrowFunction:
-		if d := decl.AsArrowFunction(); d != nil {
-			list = d.TypeParameters
-		}
-	case shimast.KindCallSignature:
-		if d := decl.AsCallSignatureDeclaration(); d != nil {
-			list = d.TypeParameters
-		}
-	case shimast.KindConstructSignature:
-		if d := decl.AsConstructSignatureDeclaration(); d != nil {
-			list = d.TypeParameters
-		}
-	}
-	if list == nil || len(list.Nodes) == 0 {
-		return nil
-	}
-	out := make([]*shimast.TypeParameterDeclaration, 0, len(list.Nodes))
-	for _, n := range list.Nodes {
-		if n == nil {
-			out = append(out, nil)
-			continue
-		}
-		out = append(out, n.AsTypeParameterDeclaration())
-	}
-	return out
+  if decl == nil {
+    return nil
+  }
+  var list *shimast.TypeParameterList
+  switch decl.Kind {
+  case shimast.KindFunctionDeclaration:
+    if d := decl.AsFunctionDeclaration(); d != nil {
+      list = d.TypeParameters
+    }
+  case shimast.KindClassDeclaration:
+    if d := decl.AsClassDeclaration(); d != nil {
+      list = d.TypeParameters
+    }
+  case shimast.KindClassExpression:
+    if d := decl.AsClassExpression(); d != nil {
+      list = d.TypeParameters
+    }
+  case shimast.KindInterfaceDeclaration:
+    if d := decl.AsInterfaceDeclaration(); d != nil {
+      list = d.TypeParameters
+    }
+  case shimast.KindTypeAliasDeclaration:
+    if d := decl.AsTypeAliasDeclaration(); d != nil {
+      list = d.TypeParameters
+    }
+  case shimast.KindMethodDeclaration:
+    if d := decl.AsMethodDeclaration(); d != nil {
+      list = d.TypeParameters
+    }
+  case shimast.KindMethodSignature:
+    if d := decl.AsMethodSignatureDeclaration(); d != nil {
+      list = d.TypeParameters
+    }
+  case shimast.KindFunctionExpression:
+    if d := decl.AsFunctionExpression(); d != nil {
+      list = d.TypeParameters
+    }
+  case shimast.KindArrowFunction:
+    if d := decl.AsArrowFunction(); d != nil {
+      list = d.TypeParameters
+    }
+  case shimast.KindCallSignature:
+    if d := decl.AsCallSignatureDeclaration(); d != nil {
+      list = d.TypeParameters
+    }
+  case shimast.KindConstructSignature:
+    if d := decl.AsConstructSignatureDeclaration(); d != nil {
+      list = d.TypeParameters
+    }
+  }
+  if list == nil || len(list.Nodes) == 0 {
+    return nil
+  }
+  out := make([]*shimast.TypeParameterDeclaration, 0, len(list.Nodes))
+  for _, n := range list.Nodes {
+    if n == nil {
+      out = append(out, nil)
+      continue
+    }
+    out = append(out, n.AsTypeParameterDeclaration())
+  }
+  return out
 }
 
 func init() {
-	Register(noUnnecessaryTypeArguments{})
+  Register(noUnnecessaryTypeArguments{})
 }

package/linthost/rules_ts_no_unnecessary_type_assertion.go

@@ -6,8 +6,8 @@
 package linthost
 
 import (
-	shimast "github.com/microsoft/typescript-go/shim/ast"
-	shimchecker "github.com/microsoft/typescript-go/shim/checker"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimchecker "github.com/microsoft/typescript-go/shim/checker"
 )
 
 // noUnnecessaryTypeAssertion reports redundant `as`, type-prefix, and
@@ -34,79 +34,79 @@ import (
 type noUnnecessaryTypeAssertion struct{}
 
 func (noUnnecessaryTypeAssertion) Name() string {
-	return "typescript/no-unnecessary-type-assertion"
+  return "typescript/no-unnecessary-type-assertion"
 }
 func (noUnnecessaryTypeAssertion) NeedsTypeChecker() bool {
-	return true
+  return true
 }
 func (noUnnecessaryTypeAssertion) Visits() []shimast.Kind {
-	return []shimast.Kind{
-		shimast.KindAsExpression,
-		shimast.KindTypeAssertionExpression,
-		shimast.KindNonNullExpression,
-	}
+  return []shimast.Kind{
+    shimast.KindAsExpression,
+    shimast.KindTypeAssertionExpression,
+    shimast.KindNonNullExpression,
+  }
 }
 func (noUnnecessaryTypeAssertion) Check(ctx *Context, node *shimast.Node) {
-	if ctx.Checker == nil {
-		return
-	}
-	switch node.Kind {
-	case shimast.KindAsExpression:
-		as := node.AsAsExpression()
-		if as == nil || as.Expression == nil || as.Type == nil {
-			return
-		}
-		if isConstTypeReference(as.Type) {
-			return
-		}
-		noUnnecessaryTypeAssertionCheckAssertion(ctx, node, as.Expression, as.Type)
-	case shimast.KindTypeAssertionExpression:
-		ta := node.AsTypeAssertion()
-		if ta == nil || ta.Expression == nil || ta.Type == nil {
-			return
-		}
-		if isConstTypeReference(ta.Type) {
-			return
-		}
-		noUnnecessaryTypeAssertionCheckAssertion(ctx, node, ta.Expression, ta.Type)
-	case shimast.KindNonNullExpression:
-		nn := node.AsNonNullExpression()
-		if nn == nil || nn.Expression == nil {
-			return
-		}
-		sourceType := ctx.Checker.GetTypeAtLocation(nn.Expression)
-		if sourceType == nil {
-			return
-		}
-		if noUnnecessaryTypeAssertionIsNullable(sourceType) {
-			return
-		}
-		ctx.Report(node, "This assertion is unnecessary since it does not change the type of the expression.")
-	}
+  if ctx.Checker == nil {
+    return
+  }
+  switch node.Kind {
+  case shimast.KindAsExpression:
+    as := node.AsAsExpression()
+    if as == nil || as.Expression == nil || as.Type == nil {
+      return
+    }
+    if isConstTypeReference(as.Type) {
+      return
+    }
+    noUnnecessaryTypeAssertionCheckAssertion(ctx, node, as.Expression, as.Type)
+  case shimast.KindTypeAssertionExpression:
+    ta := node.AsTypeAssertion()
+    if ta == nil || ta.Expression == nil || ta.Type == nil {
+      return
+    }
+    if isConstTypeReference(ta.Type) {
+      return
+    }
+    noUnnecessaryTypeAssertionCheckAssertion(ctx, node, ta.Expression, ta.Type)
+  case shimast.KindNonNullExpression:
+    nn := node.AsNonNullExpression()
+    if nn == nil || nn.Expression == nil {
+      return
+    }
+    sourceType := ctx.Checker.GetTypeAtLocation(nn.Expression)
+    if sourceType == nil {
+      return
+    }
+    if noUnnecessaryTypeAssertionIsNullable(sourceType) {
+      return
+    }
+    ctx.Report(node, "This assertion is unnecessary since it does not change the type of the expression.")
+  }
 }
 
 // noUnnecessaryTypeAssertionCheckAssertion runs the shared logic for
 // `expr as T` and `<T>expr`: report when the asserted type and source
 // type are mutually assignable.
 func noUnnecessaryTypeAssertionCheckAssertion(ctx *Context, node, expr, typeNode *shimast.Node) {
-	sourceType := ctx.Checker.GetTypeAtLocation(expr)
-	if sourceType == nil {
-		return
-	}
-	assertedType := ctx.Checker.GetTypeFromTypeNode(typeNode)
-	if assertedType == nil {
-		return
-	}
-	// Bidirectional assignability stands in for type identity: see the
-	// note on `non-nullable-type-assertion-style`. The assertion is
-	// redundant only when both sides describe the same set of values.
-	if !ctx.Checker.IsTypeAssignableTo(sourceType, assertedType) {
-		return
-	}
-	if !ctx.Checker.IsTypeAssignableTo(assertedType, sourceType) {
-		return
-	}
-	ctx.Report(node, "This assertion is unnecessary since it does not change the type of the expression.")
+  sourceType := ctx.Checker.GetTypeAtLocation(expr)
+  if sourceType == nil {
+    return
+  }
+  assertedType := ctx.Checker.GetTypeFromTypeNode(typeNode)
+  if assertedType == nil {
+    return
+  }
+  // Bidirectional assignability stands in for type identity: see the
+  // note on `non-nullable-type-assertion-style`. The assertion is
+  // redundant only when both sides describe the same set of values.
+  if !ctx.Checker.IsTypeAssignableTo(sourceType, assertedType) {
+    return
+  }
+  if !ctx.Checker.IsTypeAssignableTo(assertedType, sourceType) {
+    return
+  }
+  ctx.Report(node, "This assertion is unnecessary since it does not change the type of the expression.")
 }
 
 // isConstTypeReference reports whether the type node is the bare
@@ -117,14 +117,14 @@ func noUnnecessaryTypeAssertionCheckAssertion(ctx *Context, node, expr, typeNode
 // it because it is structurally an assertion but semantically a const
 // context request.
 func isConstTypeReference(typeNode *shimast.Node) bool {
-	if typeNode == nil || typeNode.Kind != shimast.KindTypeReference {
-		return false
-	}
-	ref := typeNode.AsTypeReferenceNode()
-	if ref == nil {
-		return false
-	}
-	return identifierText(ref.TypeName) == "const"
+  if typeNode == nil || typeNode.Kind != shimast.KindTypeReference {
+    return false
+  }
+  ref := typeNode.AsTypeReferenceNode()
+  if ref == nil {
+    return false
+  }
+  return identifierText(ref.TypeName) == "const"
 }
 
 // noUnnecessaryTypeAssertionIsNullable reports whether t carries `null`
@@ -132,26 +132,26 @@ func isConstTypeReference(typeNode *shimast.Node) bool {
 // shape mirrors `nonNullableTypeAssertionStyleIsNullable` because both
 // rules answer the same question about the source expression.
 func noUnnecessaryTypeAssertionIsNullable(t *shimchecker.Type) bool {
-	if t == nil {
-		return false
-	}
-	flags := t.Flags()
-	if flags&(shimchecker.TypeFlagsNull|shimchecker.TypeFlagsUndefined) != 0 {
-		return true
-	}
-	if flags&shimchecker.TypeFlagsUnion != 0 {
-		for _, part := range t.Types() {
-			if part == nil {
-				continue
-			}
-			if noUnnecessaryTypeAssertionIsNullable(part) {
-				return true
-			}
-		}
-	}
-	return false
+  if t == nil {
+    return false
+  }
+  flags := t.Flags()
+  if flags&(shimchecker.TypeFlagsNull|shimchecker.TypeFlagsUndefined) != 0 {
+    return true
+  }
+  if flags&shimchecker.TypeFlagsUnion != 0 {
+    for _, part := range t.Types() {
+      if part == nil {
+        continue
+      }
+      if noUnnecessaryTypeAssertionIsNullable(part) {
+        return true
+      }
+    }
+  }
+  return false
 }
 
 func init() {
-	Register(noUnnecessaryTypeAssertion{})
+  Register(noUnnecessaryTypeAssertion{})
 }