@ttsc/lint 0.13.1 → 0.14.0-dev.20260528.1

package/linthost/rules_ts_no_unnecessary_template_expression.go

@@ -0,0 +1,178 @@
+// typescript/no-unnecessary-template-expression: a backtick literal
+// that carries no template-only behavior is just noise — a regular
+// string literal renders the same characters with one fewer indirection.
+// typescript-eslint:
+// https://typescript-eslint.io/rules/no-unnecessary-template-expression/
+//
+// Type-aware. Three shapes collapse cleanly to a regular string literal:
+//
+//   - A `NoSubstitutionTemplateLiteral` with no escaped backticks. The
+//     `\`` escape is what would force the template form once converted —
+//     a regular `"..."` does not need to escape a backtick, but the
+//     surrounding lint expects an exact source-preserving rewrite, so
+//     skip the literal when one is present.
+//   - A `TemplateExpression` whose head and the one span's tail text are
+//     both empty AND whose single span's expression is statically
+//     string-typed. `` `${name}` `` then coerces a known-string value
+//     through `String()` for no reason; just use `name`.
+//   - A `TemplateExpression` whose single span's expression is a
+//     `StringLiteral` or `NoSubstitutionTemplateLiteral` literal and
+//     whose head / tail text are empty — `` `${"abc"}` `` is the same
+//     as `"abc"`, independent of any Checker state.
+//
+// Tagged templates (`` tag`abc` ``, `` tag`${x}` ``) are excluded
+// because the tag function reads the raw template payload and would
+// observe a different shape if the literal were rewritten to a string.
+package linthost
+
+import (
+	"strings"
+
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+	shimchecker "github.com/microsoft/typescript-go/shim/checker"
+)
+
+type noUnnecessaryTemplateExpression struct{}
+
+func (noUnnecessaryTemplateExpression) Name() string {
+	return "typescript/no-unnecessary-template-expression"
+}
+func (noUnnecessaryTemplateExpression) NeedsTypeChecker() bool {
+	return true
+}
+func (noUnnecessaryTemplateExpression) Visits() []shimast.Kind {
+	return []shimast.Kind{
+		shimast.KindNoSubstitutionTemplateLiteral,
+		shimast.KindTemplateExpression,
+	}
+}
+func (noUnnecessaryTemplateExpression) Check(ctx *Context, node *shimast.Node) {
+	// Tag-function readers (`String.raw`, `dedent`, `gql`, `css`, …) see
+	// the raw template payload, so rewriting to a string literal would
+	// change observable behavior. Skip the entire literal in that case,
+	// matching `no-useless-escape`.
+	if isInsideTaggedTemplate(node) {
+		return
+	}
+	switch node.Kind {
+	case shimast.KindNoSubstitutionTemplateLiteral:
+		lit := node.AsNoSubstitutionTemplateLiteral()
+		if lit == nil {
+			return
+		}
+		// `RawText` is the verbatim payload between the backticks. The
+		// presence of `\`` means the source intentionally escapes a
+		// backtick that the template-literal form requires; leave such
+		// literals alone so the rewrite is always a pure source change.
+		if strings.Contains(lit.RawText, "\\`") {
+			return
+		}
+		ctx.Report(node, noUnnecessaryTemplateExpressionMessage)
+	case shimast.KindTemplateExpression:
+		expr := node.AsTemplateExpression()
+		if expr == nil || expr.TemplateSpans == nil {
+			return
+		}
+		spans := expr.TemplateSpans.Nodes
+		if len(spans) != 1 {
+			return
+		}
+		// Head text must be empty: `` `prefix${...}` `` has surrounding
+		// chars that are load-bearing and cannot collapse.
+		head := expr.Head
+		if head == nil || templateLiteralLikeText(head) != "" {
+			return
+		}
+		span := spans[0].AsTemplateSpan()
+		if span == nil || span.Expression == nil || span.Literal == nil {
+			return
+		}
+		// Tail text must be empty for the same reason as the head.
+		if templateLiteralLikeText(span.Literal) != "" {
+			return
+		}
+		inner := span.Expression
+		// A literal string operand collapses without consulting the
+		// Checker — `` `${"abc"}` `` is identical to `"abc"`.
+		if inner.Kind == shimast.KindStringLiteral ||
+			inner.Kind == shimast.KindNoSubstitutionTemplateLiteral {
+			ctx.Report(node, noUnnecessaryTemplateExpressionMessage)
+			return
+		}
+		if ctx.Checker == nil {
+			return
+		}
+		t := ctx.Checker.GetTypeAtLocation(inner)
+		if t == nil {
+			return
+		}
+		if isStringTypedForTemplateCollapse(t) {
+			ctx.Report(node, noUnnecessaryTemplateExpressionMessage)
+		}
+	}
+}
+
+const noUnnecessaryTemplateExpressionMessage = "Unnecessary template literal — replace the backtick form with a regular string literal."
+
+// templateLiteralLikeText returns the parsed text payload of a
+// TemplateHead / TemplateMiddle / TemplateTail / NoSubstitutionTemplate-
+// Literal node. The same `Text` field lives on every shape via the
+// shared `TemplateLiteralLikeNodeBase`, so we dispatch by kind.
+func templateLiteralLikeText(node *shimast.Node) string {
+	if node == nil {
+		return ""
+	}
+	switch node.Kind {
+	case shimast.KindTemplateHead:
+		if h := node.AsTemplateHead(); h != nil {
+			return h.Text
+		}
+	case shimast.KindTemplateMiddle:
+		if m := node.AsTemplateMiddle(); m != nil {
+			return m.Text
+		}
+	case shimast.KindTemplateTail:
+		if tl := node.AsTemplateTail(); tl != nil {
+			return tl.Text
+		}
+	case shimast.KindNoSubstitutionTemplateLiteral:
+		if l := node.AsNoSubstitutionTemplateLiteral(); l != nil {
+			return l.Text
+		}
+	}
+	return ""
+}
+
+// isStringTypedForTemplateCollapse reports whether `t` is provably a
+// string-like type whose interpolation in `` `${x}` `` is a no-op
+// coercion. `any` / `unknown` / `never` are deliberately excluded so the
+// rule does not light up on generic helpers — the upstream rule's
+// `allowAny` semantics match this conservative choice. Union and
+// intersection types collapse only when every constituent is itself
+// string-like.
+func isStringTypedForTemplateCollapse(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 {
+		parts := t.Types()
+		if len(parts) == 0 {
+			return false
+		}
+		for _, part := range parts {
+			if !isStringTypedForTemplateCollapse(part) {
+				return false
+			}
+		}
+		return true
+	}
+	return flags&shimchecker.TypeFlagsStringLike != 0
+}
+
+func init() {
+	Register(noUnnecessaryTemplateExpression{})
+}

package/linthost/rules_ts_no_unnecessary_type_arguments.go

@@ -0,0 +1,234 @@
+// typescript/no-unnecessary-type-arguments: when a generic's explicit
+// type argument matches the corresponding parameter's declared default,
+// the argument is just restating the default. Dropping it leaves the
+// identical type because TypeScript would substitute the default
+// anyway. typescript-eslint:
+// https://typescript-eslint.io/rules/no-unnecessary-type-arguments/
+package linthost
+
+import (
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// noUnnecessaryTypeArguments visits the three syntactic positions that
+// carry an explicit type-argument list — `Foo<T>` in type position,
+// `new Foo<T>(…)`, and `foo<T>(…)` — and compares each argument against
+// the parameter default declared on the generic. The check is type-aware
+// because matching against the default requires resolving the generic's
+// symbol back to its parameter list; the AST alone doesn't carry that
+// link.
+//
+// The rule reports the rightmost run of arguments that equal their
+// defaults: a trailing default-equal arg can be dropped without
+// affecting the leftmost positional args. Once a non-equal arg appears
+// scanning from the right, every argument to its left must stay
+// explicit even when it equals its own default — TypeScript can only
+// omit a contiguous suffix.
+type noUnnecessaryTypeArguments struct{}
+
+func (noUnnecessaryTypeArguments) Name() string {
+	return "typescript/no-unnecessary-type-arguments"
+}
+func (noUnnecessaryTypeArguments) NeedsTypeChecker() bool {
+	return true
+}
+func (noUnnecessaryTypeArguments) Visits() []shimast.Kind {
+	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.")
+	}
+}
+
+// noUnnecessaryTypeArgumentsExtract returns the explicit type-argument
+// nodes and the identifier-or-property-access naming the generic the
+// arguments apply to. Returns (nil, nil) when the node carries no
+// 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
+}
+
+// noUnnecessaryTypeArgumentsResolveParameters resolves `nameNode` to a
+// symbol and returns the type parameters declared on the first
+// declaration that carries one. Returns nil when the symbol does not
+// 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
+}
+
+// noUnnecessaryTypeArgumentsParamList returns the type-parameter list on
+// `decl` when the declaration kind carries one, or nil otherwise. The
+// enumerated kinds match the host types TypeScript binds generic
+// arguments against — function-shaped declarations, class / interface
+// / 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
+}
+
+func init() {
+	Register(noUnnecessaryTypeArguments{})
+}

package/linthost/rules_ts_no_unnecessary_type_assertion.go

@@ -0,0 +1,157 @@
+// typescript/no-unnecessary-type-assertion: `x as T`, `<T>x`, and `x!`
+// add nothing when the static type of `x` already equals `T` (or is
+// already non-nullable, for the `!` form). typescript-eslint
+// recommended-type-checked:
+// https://typescript-eslint.io/rules/no-unnecessary-type-assertion/
+package linthost
+
+import (
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+	shimchecker "github.com/microsoft/typescript-go/shim/checker"
+)
+
+// noUnnecessaryTypeAssertion reports redundant `as`, type-prefix, and
+// non-null assertions. Implementation notes:
+//
+//   - Type-aware: requires the Checker so the source expression's static
+//     type can be compared against the asserted target. The shim
+//     re-exports the unexported `GetTypeFromTypeNode` and
+//     `IsTypeAssignableTo` methods directly, the same plumbing that the
+//     sibling `non-nullable-type-assertion-style` rule uses.
+//   - Symmetric assignability is used in place of literal type identity
+//     for the same reason as `non-nullable-type-assertion-style`: the
+//     Checker may widen literal types on one side and not the other
+//     (e.g. `"foo" as string` versus the literal `"foo"`), so requiring
+//     both directions of assignability stands in for structural
+//     equivalence without over-firing on widening.
+//   - The `as const` form is intentionally skipped because it produces
+//     a strictly narrower type than the source expression; `as const`
+//     assertions on already-literal expressions are handled by the
+//     companion `typescript/prefer-as-const` rule.
+//   - For `x!` (NonNullExpression) the rule fires when the inner
+//     expression's static type has no `null` or `undefined`
+//     constituent — the `!` strips nothing.
+type noUnnecessaryTypeAssertion struct{}
+
+func (noUnnecessaryTypeAssertion) Name() string {
+	return "typescript/no-unnecessary-type-assertion"
+}
+func (noUnnecessaryTypeAssertion) NeedsTypeChecker() bool {
+	return true
+}
+func (noUnnecessaryTypeAssertion) Visits() []shimast.Kind {
+	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.")
+	}
+}
+
+// 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.")
+}
+
+// isConstTypeReference reports whether the type node is the bare
+// identifier `const`, i.e. the `as const` syntax. The TypeScript parser
+// represents `as const` as an AsExpression / TypeAssertion whose type
+// node is a TypeReference to the identifier `const` rather than a real
+// type — every other rule that touches assertion nodes needs to skip
+// 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"
+}
+
+// noUnnecessaryTypeAssertionIsNullable reports whether t carries `null`
+// or `undefined` at the top level or inside a union constituent. The
+// 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
+}
+
+func init() {
+	Register(noUnnecessaryTypeAssertion{})
+}

package/linthost/rules_ts_no_unsafe_argument.go

@@ -0,0 +1,82 @@
+// typescript/no-unsafe-argument: passing an `any`-typed value into a
+// concretely typed parameter discards every static check the function's
+// signature would otherwise enforce. The call still runs, but the value
+// flows in unchecked and downstream uses operate on whatever the
+// runtime actually supplies. typescript-eslint:
+// https://typescript-eslint.io/rules/no-unsafe-argument/
+//
+// Type-aware. The rule visits `CallExpression` and `NewExpression` and
+// reports each argument whose static type carries `TypeFlagsAny` when
+// the callee's resolved type is itself a concrete (non-`any`) callable.
+// `unknown` is intentionally NOT flagged: it forces a narrowing
+// assertion before the call, which is the explicit ergonomic the
+// upstream rule pushes toward.
+package linthost
+
+import (
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+type noUnsafeArgument struct{}
+
+func (noUnsafeArgument) Name() string { return "typescript/no-unsafe-argument" }
+func (noUnsafeArgument) NeedsTypeChecker() bool {
+	return true
+}
+func (noUnsafeArgument) Visits() []shimast.Kind {
+	return []shimast.Kind{
+		shimast.KindCallExpression,
+		shimast.KindNewExpression,
+	}
+}
+func (noUnsafeArgument) Check(ctx *Context, node *shimast.Node) {
+	if ctx.Checker == nil {
+		return
+	}
+	var callee *shimast.Node
+	var args []*shimast.Node
+	switch node.Kind {
+	case shimast.KindCallExpression:
+		if call := node.AsCallExpression(); call != nil {
+			callee = call.Expression
+			if call.Arguments != nil {
+				args = call.Arguments.Nodes
+			}
+		}
+	case shimast.KindNewExpression:
+		if ne := node.AsNewExpression(); ne != nil {
+			callee = ne.Expression
+			if ne.Arguments != nil {
+				args = ne.Arguments.Nodes
+			}
+		}
+	}
+	if callee == nil || len(args) == 0 {
+		return
+	}
+	calleeType := ctx.Checker.GetTypeAtLocation(callee)
+	if calleeType == nil || typeIsUnsafeAny(calleeType) {
+		// Callee itself is `any` — no-unsafe-call handles that.
+		return
+	}
+	for _, arg := range args {
+		if arg == nil {
+			continue
+		}
+		stripped := stripParens(arg)
+		if stripped == nil {
+			continue
+		}
+		argType := ctx.Checker.GetTypeAtLocation(stripped)
+		if !typeIsUnsafeAny(argType) {
+			continue
+		}
+		ctx.Report(arg, noUnsafeArgumentMessage)
+	}
+}
+
+const noUnsafeArgumentMessage = "Unsafe passing of a value typed as `any` into a typed parameter. Narrow the value before forwarding it."
+
+func init() {
+	Register(noUnsafeArgument{})
+}