@ttsc/lint 0.7.1 → 0.7.3

package/plugin/rules_loops.go

@@ -9,99 +9,99 @@ type forDirection struct{}
 func (forDirection) Name() string           { return "for-direction" }
 func (forDirection) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindForStatement} }
 func (forDirection) Check(ctx *Context, node *shimast.Node) {
-	loop := node.AsForStatement()
-	if loop == nil || loop.Condition == nil || loop.Incrementor == nil {
-		return
-	}
-	cond := loop.Condition
-	if cond.Kind != shimast.KindBinaryExpression {
-		return
-	}
-	bin := cond.AsBinaryExpression()
-	if bin == nil || bin.OperatorToken == nil {
-		return
-	}
-	leftName := identifierText(bin.Left)
-	rightName := identifierText(bin.Right)
-	if leftName == "" && rightName == "" {
-		return
-	}
-	directionFromCondition := 0
-	switch bin.OperatorToken.Kind {
-	case shimast.KindLessThanToken, shimast.KindLessThanEqualsToken:
-		// `i < limit` requires increment
-		if leftName != "" {
-			directionFromCondition = +1
-		} else {
-			directionFromCondition = -1
-		}
-	case shimast.KindGreaterThanToken, shimast.KindGreaterThanEqualsToken:
-		if leftName != "" {
-			directionFromCondition = -1
-		} else {
-			directionFromCondition = +1
-		}
-	default:
-		return
-	}
-	counterName := leftName
-	if counterName == "" {
-		counterName = rightName
-	}
-	directionFromIncr := updateDirection(loop.Incrementor, counterName)
-	if directionFromIncr == 0 {
-		return
-	}
-	if directionFromIncr*directionFromCondition < 0 {
-		ctx.Report(loop.Incrementor, "The update clause in this loop moves the variable in the wrong direction.")
-	}
+  loop := node.AsForStatement()
+  if loop == nil || loop.Condition == nil || loop.Incrementor == nil {
+    return
+  }
+  cond := loop.Condition
+  if cond.Kind != shimast.KindBinaryExpression {
+    return
+  }
+  bin := cond.AsBinaryExpression()
+  if bin == nil || bin.OperatorToken == nil {
+    return
+  }
+  leftName := identifierText(bin.Left)
+  rightName := identifierText(bin.Right)
+  if leftName == "" && rightName == "" {
+    return
+  }
+  directionFromCondition := 0
+  switch bin.OperatorToken.Kind {
+  case shimast.KindLessThanToken, shimast.KindLessThanEqualsToken:
+    // `i < limit` requires increment
+    if leftName != "" {
+      directionFromCondition = +1
+    } else {
+      directionFromCondition = -1
+    }
+  case shimast.KindGreaterThanToken, shimast.KindGreaterThanEqualsToken:
+    if leftName != "" {
+      directionFromCondition = -1
+    } else {
+      directionFromCondition = +1
+    }
+  default:
+    return
+  }
+  counterName := leftName
+  if counterName == "" {
+    counterName = rightName
+  }
+  directionFromIncr := updateDirection(loop.Incrementor, counterName)
+  if directionFromIncr == 0 {
+    return
+  }
+  if directionFromIncr*directionFromCondition < 0 {
+    ctx.Report(loop.Incrementor, "The update clause in this loop moves the variable in the wrong direction.")
+  }
 }
 
 func updateDirection(node *shimast.Node, counter string) int {
-	if node == nil || counter == "" {
-		return 0
-	}
-	switch node.Kind {
-	case shimast.KindPostfixUnaryExpression:
-		post := node.AsPostfixUnaryExpression()
-		if post == nil || identifierText(post.Operand) != counter {
-			return 0
-		}
-		switch post.Operator {
-		case shimast.KindPlusPlusToken:
-			return +1
-		case shimast.KindMinusMinusToken:
-			return -1
-		}
-	case shimast.KindPrefixUnaryExpression:
-		pre := node.AsPrefixUnaryExpression()
-		if pre == nil || identifierText(pre.Operand) != counter {
-			return 0
-		}
-		switch pre.Operator {
-		case shimast.KindPlusPlusToken:
-			return +1
-		case shimast.KindMinusMinusToken:
-			return -1
-		}
-	case shimast.KindBinaryExpression:
-		bin := node.AsBinaryExpression()
-		if bin == nil || bin.OperatorToken == nil {
-			return 0
-		}
-		if identifierText(bin.Left) != counter {
-			return 0
-		}
-		switch bin.OperatorToken.Kind {
-		case shimast.KindPlusEqualsToken:
-			return +1
-		case shimast.KindMinusEqualsToken:
-			return -1
-		}
-	}
-	return 0
+  if node == nil || counter == "" {
+    return 0
+  }
+  switch node.Kind {
+  case shimast.KindPostfixUnaryExpression:
+    post := node.AsPostfixUnaryExpression()
+    if post == nil || identifierText(post.Operand) != counter {
+      return 0
+    }
+    switch post.Operator {
+    case shimast.KindPlusPlusToken:
+      return +1
+    case shimast.KindMinusMinusToken:
+      return -1
+    }
+  case shimast.KindPrefixUnaryExpression:
+    pre := node.AsPrefixUnaryExpression()
+    if pre == nil || identifierText(pre.Operand) != counter {
+      return 0
+    }
+    switch pre.Operator {
+    case shimast.KindPlusPlusToken:
+      return +1
+    case shimast.KindMinusMinusToken:
+      return -1
+    }
+  case shimast.KindBinaryExpression:
+    bin := node.AsBinaryExpression()
+    if bin == nil || bin.OperatorToken == nil {
+      return 0
+    }
+    if identifierText(bin.Left) != counter {
+      return 0
+    }
+    switch bin.OperatorToken.Kind {
+    case shimast.KindPlusEqualsToken:
+      return +1
+    case shimast.KindMinusEqualsToken:
+      return -1
+    }
+  }
+  return 0
 }
 
 func init() {
-	Register(forDirection{})
+  Register(forDirection{})
 }

package/plugin/rules_misc.go

@@ -10,39 +10,39 @@ type radix struct{}
 func (radix) Name() string           { return "radix" }
 func (radix) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindCallExpression} }
 func (radix) Check(ctx *Context, node *shimast.Node) {
-	call := node.AsCallExpression()
-	if call == nil {
-		return
-	}
-	name := callCalleeName(call)
-	if name != "parseInt" && name != "Number.parseInt" && !isMatchingPropertyAccess(call.Expression, "Number", "parseInt") {
-		return
-	}
-	args := 0
-	if call.Arguments != nil {
-		args = len(call.Arguments.Nodes)
-	}
-	if args == 0 {
-		return
-	}
-	if args == 1 {
-		ctx.Report(node, "Missing radix parameter.")
-		return
-	}
-	radixArg := call.Arguments.Nodes[1]
-	radixArg = stripParens(radixArg)
-	if radixArg == nil {
-		ctx.Report(node, "Missing radix parameter.")
-		return
-	}
-	if radixArg.Kind == shimast.KindNumericLiteral {
-		text := numericLiteralText(radixArg)
-		if text == "10" || text == "16" || text == "8" || text == "2" {
-			return
-		}
-		ctx.Report(radixArg, "Invalid radix parameter.")
-		return
-	}
+  call := node.AsCallExpression()
+  if call == nil {
+    return
+  }
+  name := callCalleeName(call)
+  if name != "parseInt" && name != "Number.parseInt" && !isMatchingPropertyAccess(call.Expression, "Number", "parseInt") {
+    return
+  }
+  args := 0
+  if call.Arguments != nil {
+    args = len(call.Arguments.Nodes)
+  }
+  if args == 0 {
+    return
+  }
+  if args == 1 {
+    ctx.Report(node, "Missing radix parameter.")
+    return
+  }
+  radixArg := call.Arguments.Nodes[1]
+  radixArg = stripParens(radixArg)
+  if radixArg == nil {
+    ctx.Report(node, "Missing radix parameter.")
+    return
+  }
+  if radixArg.Kind == shimast.KindNumericLiteral {
+    text := numericLiteralText(radixArg)
+    if text == "10" || text == "16" || text == "8" || text == "2" {
+      return
+    }
+    ctx.Report(radixArg, "Invalid radix parameter.")
+    return
+  }
 }
 
 // no-new-wrappers: `new String("")`, `new Number(0)`, `new Boolean(false)`
@@ -53,17 +53,17 @@ type noNewWrappers struct{}
 func (noNewWrappers) Name() string           { return "no-new-wrappers" }
 func (noNewWrappers) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindNewExpression} }
 func (noNewWrappers) Check(ctx *Context, node *shimast.Node) {
-	ne := node.AsNewExpression()
-	if ne == nil {
-		return
-	}
-	switch identifierText(ne.Expression) {
-	case "String", "Number", "Boolean":
-		ctx.Report(node, "Do not use "+identifierText(ne.Expression)+" as a constructor.")
-	}
+  ne := node.AsNewExpression()
+  if ne == nil {
+    return
+  }
+  switch identifierText(ne.Expression) {
+  case "String", "Number", "Boolean":
+    ctx.Report(node, "Do not use "+identifierText(ne.Expression)+" as a constructor.")
+  }
 }
 
 func init() {
-	Register(radix{})
-	Register(noNewWrappers{})
+  Register(radix{})
+  Register(noNewWrappers{})
 }