Documentation
¶
Index ¶
- func ImportRules(prefix string, bundle Bundle)
- type Bundle
- type ExprType
- type ExprValue
- type File
- type MatchedNode
- type MatchedText
- type Matcher
- func (m Matcher) At(v Var) Matcher
- func (m Matcher) File() File
- func (m Matcher) Import(pkgPath string)
- func (m Matcher) Match(pattern string, alternatives ...string) Matcher
- func (m Matcher) MatchComment(pattern string, alternatives ...string) Matcher
- func (m Matcher) Report(message string) Matcher
- func (m Matcher) Suggest(suggestion string) Matcher
- func (m Matcher) Where(cond bool) Matcher
- type String
- type Var
- type VarFilterContext
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
func ImportRules ¶
ImportRules imports all rules from the bundle and prefixes them with a specified string.
Empty string prefix is something like "dot import" in Go. Group name collisions will result in an error.
Only packages that have an exported Bundle variable can be imported.
Note: right now imported bundle can't import other bundles. This is not a fundamental limitation but rather a precaution measure before we understand how it should work better. If you need this feature, please open an issue at github.com/quasilyte/go-ruleguard.
Types ¶
type ExprType ¶
type ExprType struct {
// Size represents expression type size in bytes.
Size int
}
ExprType describes a type of a matcher expr.
func (ExprType) AssignableTo ¶
AssignableTo reports whether a type is assign-compatible with a given type. See https://golang.org/pkg/go/types/#AssignableTo.
func (ExprType) ConvertibleTo ¶
ConvertibleTo reports whether a type is conversible to a given type. See https://golang.org/pkg/go/types/#ConvertibleTo.
func (ExprType) Implements ¶
Implements reports whether a type implements a given interface. See https://golang.org/pkg/go/types/#Implements.
func (ExprType) Underlying ¶
Underlying returns expression type underlying type. See https://golang.org/pkg/go/types/#Type Underlying() method documentation. Read https://golang.org/ref/spec#Types section to learn more about underlying types.
type ExprValue ¶
type ExprValue struct{}
ExprValue describes a compile-time computable value of a matched expr.
type File ¶
type File struct {
// Name is a file base name.
Name String
// PkgPath is a file package path.
// Examples: "io/ioutil", "strings", "github.com/quasilyte/go-ruleguard/dsl".
PkgPath String
}
File represents the current Go source file.
type MatchedNode ¶
type MatchedNode struct{}
MatchedNode represents an AST node associated with a named submatch.
func (MatchedNode) Is ¶
func (MatchedNode) Is(typ string) bool
Is reports whether a matched node AST type is compatible with the specified type. A valid argument is a ast.Node implementing type name from the "go/ast" package. Examples: "BasicLit", "Expr", "Stmt", "Ident", "ParenExpr". See https://golang.org/pkg/go/ast/.
type MatchedText ¶
type MatchedText string
MatchedText represents a source text associated with a matched node.
func (MatchedText) Matches ¶
func (MatchedText) Matches(pattern string) bool
Matches reports whether the text matches the given regexp pattern.
type Matcher ¶
Matcher is a main API group-level entry point. It's used to define and configure the group rules. It also represents a map of all rule-local variables.
func (Matcher) At ¶
At binds the reported node to a named submatch. If no explicit location is given, the outermost node ($$) is used.
func (Matcher) Import ¶
Import loads given package path into a rule group imports table.
That table is used during the rules compilation.
The table has the following effect on the rules:
- For type expressions, it's used to resolve the full package paths of qualified types, like `foo.Bar`. If Import(`a/b/foo`) is called, `foo.Bar` will match `a/b/foo.Bar` type during the pattern execution.
func (Matcher) Match ¶
Match specifies a set of patterns that match a rule being defined. Pattern matching succeeds if at least 1 pattern matches.
If none of the given patterns matched, rule execution stops.
func (Matcher) MatchComment ¶ added in v0.3.2
MatchComment is like Match, but handles only comments and uses regexp patterns.
Multi-line /**/ comments are passed as a single string. Single-line // comments are passed line-by-line.
Hint: if you want to match a plain text and don't want to do meta char escaping, prepend `\Q` to your pattern. `\Qf(x)` will match `f(x)` as a plain text and there is no need to escape the `(` and `)` chars.
Named regexp capture groups can be accessed using the usual indexing notation.
Given this pattern:
`(?P<first>\d+)\.(\d+).(?P<second>\d+)`
And this input comment: `// 14.6.600`
We'll get these submatches:
m["$$"] => `14.6.600` m["first"] => `14` m["second"] => `600`
All usual filters can be applied:
Where(!m["first"].Text.Matches(`foo`))
You can use this to reject some matches (allow-list behavior).
func (Matcher) Report ¶
Report prints a message if associated rule match is successful.
A message is a string that can contain interpolated expressions. For every matched variable it's possible to interpolate their printed representation into the message text with $<name>. An entire match can be addressed with $$.
type Var ¶
type Var struct {
// Pure reports whether expr matched by var is side-effect-free.
Pure bool
// Const reports whether expr matched by var is a constant value.
Const bool
// Value is a compile-time computable value of the expression.
Value ExprValue
// Addressable reports whether the corresponding expression is addressable.
// See https://golang.org/ref/spec#Address_operators.
Addressable bool
// Type is a type of a matched expr.
//
// For function call expressions, a type is a function result type,
// but for a function expression itself it's a *types.Signature.
//
// Suppose we have a `a.b()` expression:
// `$x()` m["x"].Type is `a.b` function type
// `$x` m["x"].Type is `a.b()` function call result type
Type ExprType
// Text is a captured node text as in the source code.
Text MatchedText
// Node is a captured AST node.
Node MatchedNode
// Line is a source code line number that contains this match.
// If this match is multi-line, this is the first line number.
Line int
}
Var is a pattern variable that describes a named submatch.
func (Var) Filter ¶
func (Var) Filter(pred func(*VarFilterContext) bool) bool
Filter applies a custom predicate function on a submatch.
The callback function should use VarFilterContext to access the information that is usually accessed through Var. For example, `VarFilterContext.Type` is mapped to `Var.Type`.
type VarFilterContext ¶
VarFilterContext carries Var and environment information into the filter function. It's an input parameter type for the Var.Filter function callback.
func (*VarFilterContext) GetInterface ¶
func (*VarFilterContext) GetInterface(name typeName) *types.Interface
GetInterface finds a type value that represents an interface by a given name. Works like `types.AsInterface(ctx.GetType(name))`.
func (*VarFilterContext) GetType ¶
func (*VarFilterContext) GetType(name typeName) types.Type
GetType finds a type value by a given name. If a type can't be found (or a name is malformed), this function panics.
Source Files
Directories