@ttsc/lint 0.7.2 → 0.7.3

package/plugin/rules_protos.go

@@ -9,16 +9,16 @@ type noIterator struct{}
 
 func (noIterator) Name() string { return "no-iterator" }
 func (noIterator) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindPropertyAccessExpression}
+  return []shimast.Kind{shimast.KindPropertyAccessExpression}
 }
 func (noIterator) Check(ctx *Context, node *shimast.Node) {
-	access := node.AsPropertyAccessExpression()
-	if access == nil {
-		return
-	}
-	if identifierText(access.Name()) == "__iterator__" {
-		ctx.Report(node, "Reserved name '__iterator__'.")
-	}
+  access := node.AsPropertyAccessExpression()
+  if access == nil {
+    return
+  }
+  if identifierText(access.Name()) == "__iterator__" {
+    ctx.Report(node, "Reserved name '__iterator__'.")
+  }
 }
 
 // no-proto: `obj.__proto__` access is legacy. Use `Object.getPrototypeOf`
@@ -29,16 +29,16 @@ type noProto struct{}
 func (noProto) Name() string           { return "no-proto" }
 func (noProto) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindPropertyAccessExpression} }
 func (noProto) Check(ctx *Context, node *shimast.Node) {
-	access := node.AsPropertyAccessExpression()
-	if access == nil {
-		return
-	}
-	if identifierText(access.Name()) == "__proto__" {
-		ctx.Report(node, "The '__proto__' property is deprecated.")
-	}
+  access := node.AsPropertyAccessExpression()
+  if access == nil {
+    return
+  }
+  if identifierText(access.Name()) == "__proto__" {
+    ctx.Report(node, "The '__proto__' property is deprecated.")
+  }
 }
 
 func init() {
-	Register(noIterator{})
-	Register(noProto{})
+  Register(noIterator{})
+  Register(noProto{})
 }

package/plugin/rules_self.go

@@ -11,35 +11,35 @@ type noSelfAssign struct{}
 func (noSelfAssign) Name() string           { return "no-self-assign" }
 func (noSelfAssign) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindBinaryExpression} }
 func (noSelfAssign) Check(ctx *Context, node *shimast.Node) {
-	expr := node.AsBinaryExpression()
-	if expr == nil || expr.OperatorToken == nil {
-		return
-	}
-	if expr.OperatorToken.Kind != shimast.KindEqualsToken {
-		return
-	}
-	left := stripParens(expr.Left)
-	right := stripParens(expr.Right)
-	if left == nil || right == nil {
-		return
-	}
-	if !isAssignableLeftHand(left) {
-		return
-	}
-	if nodeText(ctx.File, left) == nodeText(ctx.File, right) {
-		ctx.Report(node, "Self-assignment of a variable.")
-	}
+  expr := node.AsBinaryExpression()
+  if expr == nil || expr.OperatorToken == nil {
+    return
+  }
+  if expr.OperatorToken.Kind != shimast.KindEqualsToken {
+    return
+  }
+  left := stripParens(expr.Left)
+  right := stripParens(expr.Right)
+  if left == nil || right == nil {
+    return
+  }
+  if !isAssignableLeftHand(left) {
+    return
+  }
+  if nodeText(ctx.File, left) == nodeText(ctx.File, right) {
+    ctx.Report(node, "Self-assignment of a variable.")
+  }
 }
 
 func isAssignableLeftHand(node *shimast.Node) bool {
-	if node == nil {
-		return false
-	}
-	switch node.Kind {
-	case shimast.KindIdentifier, shimast.KindPropertyAccessExpression, shimast.KindElementAccessExpression:
-		return true
-	}
-	return false
+  if node == nil {
+    return false
+  }
+  switch node.Kind {
+  case shimast.KindIdentifier, shimast.KindPropertyAccessExpression, shimast.KindElementAccessExpression:
+    return true
+  }
+  return false
 }
 
 // no-self-compare: `x === x`, `x !== x`, etc. Useful for catching typos
@@ -50,40 +50,40 @@ type noSelfCompare struct{}
 func (noSelfCompare) Name() string           { return "no-self-compare" }
 func (noSelfCompare) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindBinaryExpression} }
 func (noSelfCompare) Check(ctx *Context, node *shimast.Node) {
-	expr := node.AsBinaryExpression()
-	if expr == nil || expr.OperatorToken == nil {
-		return
-	}
-	if !isComparisonOperator(expr.OperatorToken.Kind) {
-		return
-	}
-	left := stripParens(expr.Left)
-	right := stripParens(expr.Right)
-	if left == nil || right == nil {
-		return
-	}
-	if nodeText(ctx.File, left) == nodeText(ctx.File, right) {
-		ctx.Report(node, "Comparing to itself is potentially pointless.")
-	}
+  expr := node.AsBinaryExpression()
+  if expr == nil || expr.OperatorToken == nil {
+    return
+  }
+  if !isComparisonOperator(expr.OperatorToken.Kind) {
+    return
+  }
+  left := stripParens(expr.Left)
+  right := stripParens(expr.Right)
+  if left == nil || right == nil {
+    return
+  }
+  if nodeText(ctx.File, left) == nodeText(ctx.File, right) {
+    ctx.Report(node, "Comparing to itself is potentially pointless.")
+  }
 }
 
 func isComparisonOperator(kind shimast.Kind) bool {
-	switch kind {
-	case
-		shimast.KindEqualsEqualsToken,
-		shimast.KindEqualsEqualsEqualsToken,
-		shimast.KindExclamationEqualsToken,
-		shimast.KindExclamationEqualsEqualsToken,
-		shimast.KindLessThanToken,
-		shimast.KindGreaterThanToken,
-		shimast.KindLessThanEqualsToken,
-		shimast.KindGreaterThanEqualsToken:
-		return true
-	}
-	return false
+  switch kind {
+  case
+    shimast.KindEqualsEqualsToken,
+    shimast.KindEqualsEqualsEqualsToken,
+    shimast.KindExclamationEqualsToken,
+    shimast.KindExclamationEqualsEqualsToken,
+    shimast.KindLessThanToken,
+    shimast.KindGreaterThanToken,
+    shimast.KindLessThanEqualsToken,
+    shimast.KindGreaterThanEqualsToken:
+    return true
+  }
+  return false
 }
 
 func init() {
-	Register(noSelfAssign{})
-	Register(noSelfCompare{})
+  Register(noSelfAssign{})
+  Register(noSelfCompare{})
 }

package/plugin/rules_strings.go

@@ -1,9 +1,9 @@
 package main
 
 import (
-	"strings"
+  "strings"
 
-	shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
 // no-template-curly-in-string: a regular string contains `${...}`. The
@@ -13,33 +13,33 @@ type noTemplateCurlyInString struct{}
 
 func (noTemplateCurlyInString) Name() string { return "no-template-curly-in-string" }
 func (noTemplateCurlyInString) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindStringLiteral}
+  return []shimast.Kind{shimast.KindStringLiteral}
 }
 func (noTemplateCurlyInString) Check(ctx *Context, node *shimast.Node) {
-	text := stringLiteralText(node)
-	if hasTemplatePlaceholder(text) {
-		ctx.Report(node, "Unexpected template string expression in regular string.")
-	}
+  text := stringLiteralText(node)
+  if hasTemplatePlaceholder(text) {
+    ctx.Report(node, "Unexpected template string expression in regular string.")
+  }
 }
 
 func hasTemplatePlaceholder(text string) bool {
-	if !strings.Contains(text, "${") {
-		return false
-	}
-	// Match `${ ... }` style, not just literal "${" with nothing after.
-	idx := strings.Index(text, "${")
-	for idx >= 0 {
-		rest := text[idx+2:]
-		if strings.Contains(rest, "}") {
-			return true
-		}
-		next := strings.Index(text[idx+1:], "${")
-		if next < 0 {
-			return false
-		}
-		idx += next + 1
-	}
-	return false
+  if !strings.Contains(text, "${") {
+    return false
+  }
+  // Match `${ ... }` style, not just literal "${" with nothing after.
+  idx := strings.Index(text, "${")
+  for idx >= 0 {
+    rest := text[idx+2:]
+    if strings.Contains(rest, "}") {
+      return true
+    }
+    next := strings.Index(text[idx+1:], "${")
+    if next < 0 {
+      return false
+    }
+    idx += next + 1
+  }
+  return false
 }
 
 // no-multi-str: `"line one \\n line two"` style backslash continuations.
@@ -50,23 +50,23 @@ type noMultiStr struct{}
 func (noMultiStr) Name() string           { return "no-multi-str" }
 func (noMultiStr) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindStringLiteral} }
 func (noMultiStr) Check(ctx *Context, node *shimast.Node) {
-	src := nodeText(ctx.File, node)
-	// Look for `\` immediately before a newline in the *raw* source text.
-	if hasBackslashLineContinuation(src) {
-		ctx.Report(node, "Multiline support is limited to comments.")
-	}
+  src := nodeText(ctx.File, node)
+  // Look for `\` immediately before a newline in the *raw* source text.
+  if hasBackslashLineContinuation(src) {
+    ctx.Report(node, "Multiline support is limited to comments.")
+  }
 }
 
 func hasBackslashLineContinuation(src string) bool {
-	for i := 0; i < len(src)-1; i++ {
-		if src[i] == '\\' {
-			next := src[i+1]
-			if next == '\n' || next == '\r' {
-				return true
-			}
-		}
-	}
-	return false
+  for i := 0; i < len(src)-1; i++ {
+    if src[i] == '\\' {
+      next := src[i+1]
+      if next == '\n' || next == '\r' {
+        return true
+      }
+    }
+  }
+  return false
 }
 
 // no-useless-concat: `"a" + "b"` of two literals. The compiler can't
@@ -77,27 +77,27 @@ type noUselessConcat struct{}
 func (noUselessConcat) Name() string           { return "no-useless-concat" }
 func (noUselessConcat) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindBinaryExpression} }
 func (noUselessConcat) Check(ctx *Context, node *shimast.Node) {
-	expr := node.AsBinaryExpression()
-	if expr == nil || expr.OperatorToken == nil {
-		return
-	}
-	if expr.OperatorToken.Kind != shimast.KindPlusToken {
-		return
-	}
-	if isStringLikeLiteral(stripParens(expr.Left)) && isStringLikeLiteral(stripParens(expr.Right)) {
-		ctx.Report(node, "Unexpected string concatenation of literals.")
-	}
+  expr := node.AsBinaryExpression()
+  if expr == nil || expr.OperatorToken == nil {
+    return
+  }
+  if expr.OperatorToken.Kind != shimast.KindPlusToken {
+    return
+  }
+  if isStringLikeLiteral(stripParens(expr.Left)) && isStringLikeLiteral(stripParens(expr.Right)) {
+    ctx.Report(node, "Unexpected string concatenation of literals.")
+  }
 }
 
 func isStringLikeLiteral(node *shimast.Node) bool {
-	if node == nil {
-		return false
-	}
-	switch node.Kind {
-	case shimast.KindStringLiteral, shimast.KindNoSubstitutionTemplateLiteral:
-		return true
-	}
-	return false
+  if node == nil {
+    return false
+  }
+  switch node.Kind {
+  case shimast.KindStringLiteral, shimast.KindNoSubstitutionTemplateLiteral:
+    return true
+  }
+  return false
 }
 
 // no-octal: `010` octal literal. Has to be opt-in via `0o10` in
@@ -108,18 +108,18 @@ type noOctal struct{}
 func (noOctal) Name() string           { return "no-octal" }
 func (noOctal) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindNumericLiteral} }
 func (noOctal) Check(ctx *Context, node *shimast.Node) {
-	src := nodeText(ctx.File, node)
-	src = strings.TrimLeft(src, " \t")
-	if len(src) >= 2 && src[0] == '0' && isAsciiDigit(src[1]) {
-		ctx.Report(node, "Octal literals should not be used.")
-	}
+  src := nodeText(ctx.File, node)
+  src = strings.TrimLeft(src, " \t")
+  if len(src) >= 2 && src[0] == '0' && isAsciiDigit(src[1]) {
+    ctx.Report(node, "Octal literals should not be used.")
+  }
 }
 
 func isAsciiDigit(b byte) bool { return b >= '0' && b <= '9' }
 
 func init() {
-	Register(noTemplateCurlyInString{})
-	Register(noMultiStr{})
-	Register(noUselessConcat{})
-	Register(noOctal{})
+  Register(noTemplateCurlyInString{})
+  Register(noMultiStr{})
+  Register(noUselessConcat{})
+  Register(noOctal{})
 }