@ttsc/lint 0.14.0-dev.20260529.1 → 0.14.0

package/linthost/rules_ts_sort_type_constituents.go

@@ -9,10 +9,10 @@
 package linthost
 
 import (
-	"sort"
-	"strings"
+  "sort"
+  "strings"
 
-	shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
 // sortTypeConstituents fires on `UnionType` and `IntersectionType` when
@@ -28,100 +28,100 @@ import (
 type sortTypeConstituents struct{}
 
 func (sortTypeConstituents) Name() string {
-	return "typescript/sort-type-constituents"
+  return "typescript/sort-type-constituents"
 }
 func (sortTypeConstituents) Visits() []shimast.Kind {
-	return []shimast.Kind{
-		shimast.KindUnionType,
-		shimast.KindIntersectionType,
-	}
+  return []shimast.Kind{
+    shimast.KindUnionType,
+    shimast.KindIntersectionType,
+  }
 }
 func (sortTypeConstituents) Check(ctx *Context, node *shimast.Node) {
-	types := unionOrIntersectionTypes(node)
-	if len(types) < 2 {
-		return
-	}
-	// Skip nested unions/intersections — the outermost shape is the one
-	// the user wrote, and reporting on every nesting level would
-	// double-fire on `(A | B) | C` shapes.
-	if node.Parent != nil &&
-		(node.Parent.Kind == shimast.KindUnionType || node.Parent.Kind == shimast.KindIntersectionType) {
-		return
-	}
-	entries := make([]sortTypeConstituentsEntry, len(types))
-	for i, t := range types {
-		entries[i] = sortTypeConstituentsEntry{
-			index: i,
-			group: sortTypeConstituentsClassify(t),
-			text:  strings.TrimSpace(nodeText(ctx.File, t)),
-		}
-	}
-	sorted := make([]sortTypeConstituentsEntry, len(entries))
-	copy(sorted, entries)
-	sort.SliceStable(sorted, func(i, j int) bool {
-		if sorted[i].group != sorted[j].group {
-			return sorted[i].group < sorted[j].group
-		}
-		return sorted[i].text < sorted[j].text
-	})
-	for i := range entries {
-		if entries[i].index != sorted[i].index {
-			label := "union"
-			if node.Kind == shimast.KindIntersectionType {
-				label = "intersection"
-			}
-			ctx.Report(node, "Constituents of the "+label+" are not in the canonical order — primitives alphabetized first, named types alphabetized next, `null` / `undefined` last.")
-			return
-		}
-	}
+  types := unionOrIntersectionTypes(node)
+  if len(types) < 2 {
+    return
+  }
+  // Skip nested unions/intersections — the outermost shape is the one
+  // the user wrote, and reporting on every nesting level would
+  // double-fire on `(A | B) | C` shapes.
+  if node.Parent != nil &&
+    (node.Parent.Kind == shimast.KindUnionType || node.Parent.Kind == shimast.KindIntersectionType) {
+    return
+  }
+  entries := make([]sortTypeConstituentsEntry, len(types))
+  for i, t := range types {
+    entries[i] = sortTypeConstituentsEntry{
+      index: i,
+      group: sortTypeConstituentsClassify(t),
+      text:  strings.TrimSpace(nodeText(ctx.File, t)),
+    }
+  }
+  sorted := make([]sortTypeConstituentsEntry, len(entries))
+  copy(sorted, entries)
+  sort.SliceStable(sorted, func(i, j int) bool {
+    if sorted[i].group != sorted[j].group {
+      return sorted[i].group < sorted[j].group
+    }
+    return sorted[i].text < sorted[j].text
+  })
+  for i := range entries {
+    if entries[i].index != sorted[i].index {
+      label := "union"
+      if node.Kind == shimast.KindIntersectionType {
+        label = "intersection"
+      }
+      ctx.Report(node, "Constituents of the "+label+" are not in the canonical order — primitives alphabetized first, named types alphabetized next, `null` / `undefined` last.")
+      return
+    }
+  }
 }
 
 // sortTypeConstituentsEntry is one constituent's sort key. `index`
 // records the original position so the reorder check can compare the
 // before/after sequences without losing identity.
 type sortTypeConstituentsEntry struct {
-	index int
-	group int
-	text  string
+  index int
+  group int
+  text  string
 }
 
 // sortTypeConstituentsClassify buckets a constituent into one of the
 // canonical groups. Smaller numbers come first in the canonical order.
 func sortTypeConstituentsClassify(node *shimast.Node) int {
-	if node == nil {
-		return sortTypeConstituentsGroupNamed
-	}
-	switch node.Kind {
-	case shimast.KindStringKeyword,
-		shimast.KindNumberKeyword,
-		shimast.KindBooleanKeyword,
-		shimast.KindBigIntKeyword,
-		shimast.KindSymbolKeyword,
-		shimast.KindAnyKeyword,
-		shimast.KindUnknownKeyword,
-		shimast.KindVoidKeyword,
-		shimast.KindNeverKeyword,
-		shimast.KindObjectKeyword:
-		return sortTypeConstituentsGroupPrimitive
-	case shimast.KindLiteralType:
-		// `null` and `undefined` parse as LiteralType / undefined
-		// keyword inside type position — surface them as the nullish
-		// group so the canonical order keeps them at the end.
-		if sortTypeConstituentsIsNullish(node) {
-			return sortTypeConstituentsGroupNullish
-		}
-		return sortTypeConstituentsGroupLiteral
-	case shimast.KindUndefinedKeyword, shimast.KindNullKeyword:
-		return sortTypeConstituentsGroupNullish
-	}
-	return sortTypeConstituentsGroupNamed
+  if node == nil {
+    return sortTypeConstituentsGroupNamed
+  }
+  switch node.Kind {
+  case shimast.KindStringKeyword,
+    shimast.KindNumberKeyword,
+    shimast.KindBooleanKeyword,
+    shimast.KindBigIntKeyword,
+    shimast.KindSymbolKeyword,
+    shimast.KindAnyKeyword,
+    shimast.KindUnknownKeyword,
+    shimast.KindVoidKeyword,
+    shimast.KindNeverKeyword,
+    shimast.KindObjectKeyword:
+    return sortTypeConstituentsGroupPrimitive
+  case shimast.KindLiteralType:
+    // `null` and `undefined` parse as LiteralType / undefined
+    // keyword inside type position — surface them as the nullish
+    // group so the canonical order keeps them at the end.
+    if sortTypeConstituentsIsNullish(node) {
+      return sortTypeConstituentsGroupNullish
+    }
+    return sortTypeConstituentsGroupLiteral
+  case shimast.KindUndefinedKeyword, shimast.KindNullKeyword:
+    return sortTypeConstituentsGroupNullish
+  }
+  return sortTypeConstituentsGroupNamed
 }
 
 const (
-	sortTypeConstituentsGroupPrimitive = iota
-	sortTypeConstituentsGroupLiteral
-	sortTypeConstituentsGroupNamed
-	sortTypeConstituentsGroupNullish
+  sortTypeConstituentsGroupPrimitive = iota
+  sortTypeConstituentsGroupLiteral
+  sortTypeConstituentsGroupNamed
+  sortTypeConstituentsGroupNullish
 )
 
 // sortTypeConstituentsIsNullish reports whether a LiteralType node
@@ -129,16 +129,16 @@ const (
 // position is a regular Identifier-shaped reference and is handled by
 // the named group, not by this helper.
 func sortTypeConstituentsIsNullish(node *shimast.Node) bool {
-	if node == nil || node.Kind != shimast.KindLiteralType {
-		return false
-	}
-	lit := node.AsLiteralTypeNode()
-	if lit == nil || lit.Literal == nil {
-		return false
-	}
-	return lit.Literal.Kind == shimast.KindNullKeyword
+  if node == nil || node.Kind != shimast.KindLiteralType {
+    return false
+  }
+  lit := node.AsLiteralTypeNode()
+  if lit == nil || lit.Literal == nil {
+    return false
+  }
+  return lit.Literal.Kind == shimast.KindNullKeyword
 }
 
 func init() {
-	Register(sortTypeConstituents{})
+  Register(sortTypeConstituents{})
 }

package/linthost/rules_ts_strict_boolean_expressions.go

@@ -21,70 +21,70 @@
 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"
 )
 
 type strictBooleanExpressions struct{}
 
 func (strictBooleanExpressions) Name() string { return "typescript/strict-boolean-expressions" }
 func (strictBooleanExpressions) NeedsTypeChecker() bool {
-	return true
+  return true
 }
 func (strictBooleanExpressions) Visits() []shimast.Kind {
-	return []shimast.Kind{
-		shimast.KindIfStatement,
-		shimast.KindWhileStatement,
-		shimast.KindDoStatement,
-		shimast.KindForStatement,
-		shimast.KindConditionalExpression,
-		shimast.KindPrefixUnaryExpression,
-		shimast.KindBinaryExpression,
-	}
+  return []shimast.Kind{
+    shimast.KindIfStatement,
+    shimast.KindWhileStatement,
+    shimast.KindDoStatement,
+    shimast.KindForStatement,
+    shimast.KindConditionalExpression,
+    shimast.KindPrefixUnaryExpression,
+    shimast.KindBinaryExpression,
+  }
 }
 func (strictBooleanExpressions) Check(ctx *Context, node *shimast.Node) {
-	if ctx.Checker == nil {
-		return
-	}
-	switch node.Kind {
-	case shimast.KindIfStatement:
-		if stmt := node.AsIfStatement(); stmt != nil {
-			strictBooleanExpressionsReport(ctx, stmt.Expression)
-		}
-	case shimast.KindWhileStatement:
-		if stmt := node.AsWhileStatement(); stmt != nil {
-			strictBooleanExpressionsReport(ctx, stmt.Expression)
-		}
-	case shimast.KindDoStatement:
-		if stmt := node.AsDoStatement(); stmt != nil {
-			strictBooleanExpressionsReport(ctx, stmt.Expression)
-		}
-	case shimast.KindForStatement:
-		if stmt := node.AsForStatement(); stmt != nil {
-			strictBooleanExpressionsReport(ctx, stmt.Condition)
-		}
-	case shimast.KindConditionalExpression:
-		if expr := node.AsConditionalExpression(); expr != nil {
-			strictBooleanExpressionsReport(ctx, expr.Condition)
-		}
-	case shimast.KindPrefixUnaryExpression:
-		expr := node.AsPrefixUnaryExpression()
-		if expr != nil && expr.Operator == shimast.KindExclamationToken {
-			strictBooleanExpressionsReport(ctx, expr.Operand)
-		}
-	case shimast.KindBinaryExpression:
-		bin := node.AsBinaryExpression()
-		if bin == nil || bin.OperatorToken == nil {
-			return
-		}
-		// Only `&&` / `||` test their left operand for truthiness.
-		// `??` short-circuits on nullish, not on falsy, so a non-boolean
-		// left operand is exactly the point of `??` and is not flagged.
-		switch bin.OperatorToken.Kind {
-		case shimast.KindAmpersandAmpersandToken, shimast.KindBarBarToken:
-			strictBooleanExpressionsReport(ctx, bin.Left)
-		}
-	}
+  if ctx.Checker == nil {
+    return
+  }
+  switch node.Kind {
+  case shimast.KindIfStatement:
+    if stmt := node.AsIfStatement(); stmt != nil {
+      strictBooleanExpressionsReport(ctx, stmt.Expression)
+    }
+  case shimast.KindWhileStatement:
+    if stmt := node.AsWhileStatement(); stmt != nil {
+      strictBooleanExpressionsReport(ctx, stmt.Expression)
+    }
+  case shimast.KindDoStatement:
+    if stmt := node.AsDoStatement(); stmt != nil {
+      strictBooleanExpressionsReport(ctx, stmt.Expression)
+    }
+  case shimast.KindForStatement:
+    if stmt := node.AsForStatement(); stmt != nil {
+      strictBooleanExpressionsReport(ctx, stmt.Condition)
+    }
+  case shimast.KindConditionalExpression:
+    if expr := node.AsConditionalExpression(); expr != nil {
+      strictBooleanExpressionsReport(ctx, expr.Condition)
+    }
+  case shimast.KindPrefixUnaryExpression:
+    expr := node.AsPrefixUnaryExpression()
+    if expr != nil && expr.Operator == shimast.KindExclamationToken {
+      strictBooleanExpressionsReport(ctx, expr.Operand)
+    }
+  case shimast.KindBinaryExpression:
+    bin := node.AsBinaryExpression()
+    if bin == nil || bin.OperatorToken == nil {
+      return
+    }
+    // Only `&&` / `||` test their left operand for truthiness.
+    // `??` short-circuits on nullish, not on falsy, so a non-boolean
+    // left operand is exactly the point of `??` and is not flagged.
+    switch bin.OperatorToken.Kind {
+    case shimast.KindAmpersandAmpersandToken, shimast.KindBarBarToken:
+      strictBooleanExpressionsReport(ctx, bin.Left)
+    }
+  }
 }
 
 // strictBooleanExpressionsReport flags `expr` when its static type is
@@ -93,35 +93,35 @@ func (strictBooleanExpressions) Check(ctx *Context, node *shimast.Node) {
 // upstream rule. Parenthesized wrappers are skipped via stripParens
 // so `if ((x))` resolves to `x`.
 func strictBooleanExpressionsReport(ctx *Context, expr *shimast.Node) {
-	if expr == nil {
-		return
-	}
-	expr = stripParens(expr)
-	if expr == nil {
-		return
-	}
-	// Descend through `&&` / `||` — each conjunct/disjunct sits in
-	// boolean position too. The outer BinaryExpression visit only
-	// checks Left; the descent here finds Right as well.
-	if expr.Kind == shimast.KindBinaryExpression {
-		bin := expr.AsBinaryExpression()
-		if bin != nil && bin.OperatorToken != nil {
-			switch bin.OperatorToken.Kind {
-			case shimast.KindAmpersandAmpersandToken, shimast.KindBarBarToken:
-				strictBooleanExpressionsReport(ctx, bin.Left)
-				strictBooleanExpressionsReport(ctx, bin.Right)
-				return
-			}
-		}
-	}
-	t := ctx.Checker.GetTypeAtLocation(expr)
-	if t == nil {
-		return
-	}
-	if strictBooleanExpressionsIsBoolean(t) {
-		return
-	}
-	ctx.Report(expr, "Unexpected non-boolean value in a boolean conditional position. Use an explicit comparison (`!== 0`, `.length > 0`, `!= null`) to name the intent.")
+  if expr == nil {
+    return
+  }
+  expr = stripParens(expr)
+  if expr == nil {
+    return
+  }
+  // Descend through `&&` / `||` — each conjunct/disjunct sits in
+  // boolean position too. The outer BinaryExpression visit only
+  // checks Left; the descent here finds Right as well.
+  if expr.Kind == shimast.KindBinaryExpression {
+    bin := expr.AsBinaryExpression()
+    if bin != nil && bin.OperatorToken != nil {
+      switch bin.OperatorToken.Kind {
+      case shimast.KindAmpersandAmpersandToken, shimast.KindBarBarToken:
+        strictBooleanExpressionsReport(ctx, bin.Left)
+        strictBooleanExpressionsReport(ctx, bin.Right)
+        return
+      }
+    }
+  }
+  t := ctx.Checker.GetTypeAtLocation(expr)
+  if t == nil {
+    return
+  }
+  if strictBooleanExpressionsIsBoolean(t) {
+    return
+  }
+  ctx.Report(expr, "Unexpected non-boolean value in a boolean conditional position. Use an explicit comparison (`!== 0`, `.length > 0`, `!= null`) to name the intent.")
 }
 
 // strictBooleanExpressionsIsBoolean reports whether t is pure
@@ -131,27 +131,27 @@ func strictBooleanExpressionsReport(ctx *Context, expr *shimast.Node) {
 // conditional. Union and intersection types must have every
 // constituent boolean for the whole type to count.
 func strictBooleanExpressionsIsBoolean(t *shimchecker.Type) bool {
-	if t == nil {
-		return false
-	}
-	flags := t.Flags()
-	if flags&(shimchecker.TypeFlagsAny|shimchecker.TypeFlagsUnknown|shimchecker.TypeFlagsNever) != 0 {
-		return false
-	}
-	if flags&(shimchecker.TypeFlagsUnion|shimchecker.TypeFlagsIntersection) != 0 {
-		for _, part := range t.Types() {
-			if part == nil {
-				continue
-			}
-			if !strictBooleanExpressionsIsBoolean(part) {
-				return false
-			}
-		}
-		return true
-	}
-	return flags&shimchecker.TypeFlagsBooleanLike != 0
+  if t == nil {
+    return false
+  }
+  flags := t.Flags()
+  if flags&(shimchecker.TypeFlagsAny|shimchecker.TypeFlagsUnknown|shimchecker.TypeFlagsNever) != 0 {
+    return false
+  }
+  if flags&(shimchecker.TypeFlagsUnion|shimchecker.TypeFlagsIntersection) != 0 {
+    for _, part := range t.Types() {
+      if part == nil {
+        continue
+      }
+      if !strictBooleanExpressionsIsBoolean(part) {
+        return false
+      }
+    }
+    return true
+  }
+  return flags&shimchecker.TypeFlagsBooleanLike != 0
 }
 
 func init() {
-	Register(strictBooleanExpressions{})
+  Register(strictBooleanExpressions{})
 }

package/linthost/rules_ts_switch_exhaustiveness_check.go

@@ -9,8 +9,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"
 )
 
 // switchExhaustivenessCheck is type-aware: the discriminant is resolved
@@ -31,67 +31,67 @@ type switchExhaustivenessCheck struct{}
 
 func (switchExhaustivenessCheck) Name() string { return "typescript/switch-exhaustiveness-check" }
 func (switchExhaustivenessCheck) NeedsTypeChecker() bool {
-	return true
+  return true
 }
 func (switchExhaustivenessCheck) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindSwitchStatement}
+  return []shimast.Kind{shimast.KindSwitchStatement}
 }
 func (switchExhaustivenessCheck) Check(ctx *Context, node *shimast.Node) {
-	if ctx.Checker == nil {
-		return
-	}
-	sw := node.AsSwitchStatement()
-	if sw == nil || sw.Expression == nil || sw.CaseBlock == nil {
-		return
-	}
-	block := sw.CaseBlock.AsCaseBlock()
-	if block == nil || block.Clauses == nil {
-		return
-	}
-	// A `default` clause covers anything not enumerated above, so the
-	// rule has nothing to add. typescript-eslint also exits early in
-	// this case.
-	for _, clause := range block.Clauses.Nodes {
-		if clause != nil && clause.Kind == shimast.KindDefaultClause {
-			return
-		}
-	}
-	discriminantType := ctx.Checker.GetTypeAtLocation(sw.Expression)
-	if discriminantType == nil {
-		return
-	}
-	// Only consider discriminants whose static type is a finite union of
-	// literal-like constituents. Plain `string` / `number` / `unknown`
-	// are open-ended and never exhaustively coverable.
-	members := switchExhaustivenessCheckCollectMembers(discriminantType)
-	if len(members) == 0 {
-		return
-	}
-	covered := make(map[*shimchecker.Type]bool, len(members))
-	for _, clause := range block.Clauses.Nodes {
-		if clause == nil || clause.Kind != shimast.KindCaseClause {
-			continue
-		}
-		caseClause := clause.AsCaseOrDefaultClause()
-		if caseClause == nil || caseClause.Expression == nil {
-			continue
-		}
-		caseType := ctx.Checker.GetTypeAtLocation(caseClause.Expression)
-		if caseType == nil {
-			continue
-		}
-		covered[caseType] = true
-	}
-	missing := 0
-	for _, member := range members {
-		if !covered[member] {
-			missing++
-		}
-	}
-	if missing == 0 {
-		return
-	}
-	ctx.Report(node, "Switch is not exhaustive. Cases not matched: add a `case` for every union/enum member, or include a `default` clause.")
+  if ctx.Checker == nil {
+    return
+  }
+  sw := node.AsSwitchStatement()
+  if sw == nil || sw.Expression == nil || sw.CaseBlock == nil {
+    return
+  }
+  block := sw.CaseBlock.AsCaseBlock()
+  if block == nil || block.Clauses == nil {
+    return
+  }
+  // A `default` clause covers anything not enumerated above, so the
+  // rule has nothing to add. typescript-eslint also exits early in
+  // this case.
+  for _, clause := range block.Clauses.Nodes {
+    if clause != nil && clause.Kind == shimast.KindDefaultClause {
+      return
+    }
+  }
+  discriminantType := ctx.Checker.GetTypeAtLocation(sw.Expression)
+  if discriminantType == nil {
+    return
+  }
+  // Only consider discriminants whose static type is a finite union of
+  // literal-like constituents. Plain `string` / `number` / `unknown`
+  // are open-ended and never exhaustively coverable.
+  members := switchExhaustivenessCheckCollectMembers(discriminantType)
+  if len(members) == 0 {
+    return
+  }
+  covered := make(map[*shimchecker.Type]bool, len(members))
+  for _, clause := range block.Clauses.Nodes {
+    if clause == nil || clause.Kind != shimast.KindCaseClause {
+      continue
+    }
+    caseClause := clause.AsCaseOrDefaultClause()
+    if caseClause == nil || caseClause.Expression == nil {
+      continue
+    }
+    caseType := ctx.Checker.GetTypeAtLocation(caseClause.Expression)
+    if caseType == nil {
+      continue
+    }
+    covered[caseType] = true
+  }
+  missing := 0
+  for _, member := range members {
+    if !covered[member] {
+      missing++
+    }
+  }
+  if missing == 0 {
+    return
+  }
+  ctx.Report(node, "Switch is not exhaustive. Cases not matched: add a `case` for every union/enum member, or include a `default` clause.")
 }
 
 // switchExhaustivenessCheckCollectMembers returns the finite literal /
@@ -102,28 +102,28 @@ func (switchExhaustivenessCheck) Check(ctx *Context, node *shimast.Node) {
 // (e.g. `string` mixed into `"a" | "b" | string`) widens the union and
 // disqualifies the whole discriminant.
 func switchExhaustivenessCheckCollectMembers(t *shimchecker.Type) []*shimchecker.Type {
-	if t == nil {
-		return nil
-	}
-	flags := t.Flags()
-	if flags&shimchecker.TypeFlagsUnion == 0 {
-		return nil
-	}
-	parts := t.Types()
-	if len(parts) == 0 {
-		return nil
-	}
-	members := make([]*shimchecker.Type, 0, len(parts))
-	for _, part := range parts {
-		if part == nil {
-			return nil
-		}
-		if !switchExhaustivenessCheckIsLiteralLike(part) {
-			return nil
-		}
-		members = append(members, part)
-	}
-	return members
+  if t == nil {
+    return nil
+  }
+  flags := t.Flags()
+  if flags&shimchecker.TypeFlagsUnion == 0 {
+    return nil
+  }
+  parts := t.Types()
+  if len(parts) == 0 {
+    return nil
+  }
+  members := make([]*shimchecker.Type, 0, len(parts))
+  for _, part := range parts {
+    if part == nil {
+      return nil
+    }
+    if !switchExhaustivenessCheckIsLiteralLike(part) {
+      return nil
+    }
+    members = append(members, part)
+  }
+  return members
 }
 
 // switchExhaustivenessCheckIsLiteralLike reports whether t is a
@@ -132,16 +132,16 @@ func switchExhaustivenessCheckCollectMembers(t *shimchecker.Type) []*shimchecker
 // the nullish singletons. The matching set mirrors typescript-eslint's
 // `lib.isTypeFlagSet(constituent, TypeFlags.Literal | ...)` filter.
 func switchExhaustivenessCheckIsLiteralLike(t *shimchecker.Type) bool {
-	flags := t.Flags()
-	if flags&shimchecker.TypeFlagsLiteral != 0 {
-		return true
-	}
-	if flags&(shimchecker.TypeFlagsUndefined|shimchecker.TypeFlagsNull|shimchecker.TypeFlagsVoid) != 0 {
-		return true
-	}
-	return false
+  flags := t.Flags()
+  if flags&shimchecker.TypeFlagsLiteral != 0 {
+    return true
+  }
+  if flags&(shimchecker.TypeFlagsUndefined|shimchecker.TypeFlagsNull|shimchecker.TypeFlagsVoid) != 0 {
+    return true
+  }
+  return false
 }
 
 func init() {
-	Register(switchExhaustivenessCheck{})
+  Register(switchExhaustivenessCheck{})
 }