Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func ImportRules

func ImportRules(prefix string, bundle Bundle)

    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 Bundle

    type Bundle struct {
    }

      Bundle is a rules file export manifest.

      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

        func (ExprType) AssignableTo(typ string) bool

          AssignableTo reports whether a type is assign-compatible with a given type. See https://golang.org/pkg/go/types/#AssignableTo.

          func (ExprType) ConvertibleTo

          func (ExprType) ConvertibleTo(typ string) bool

            ConvertibleTo reports whether a type is conversible to a given type. See https://golang.org/pkg/go/types/#ConvertibleTo.

            func (ExprType) Implements

            func (ExprType) Implements(typ typeName) bool

              Implements reports whether a type implements a given interface. See https://golang.org/pkg/go/types/#Implements.

              func (ExprType) Is

              func (ExprType) Is(typ string) bool

                Is reports whether a type is identical to a given type.

                func (ExprType) Underlying

                func (ExprType) Underlying() ExprType

                  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.

                    func (ExprValue) Int

                    func (ExprValue) Int() int

                      Int returns compile-time computable int value of the expression. If value can't be computed, condition will fail.

                      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.

                        func (File) Imports

                        func (File) Imports(path string) bool

                          Imports reports whether the current file imports the given path.

                          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

                                  type Matcher map[string]Var

                                    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

                                    func (m Matcher) At(v Var) Matcher

                                      At binds the reported node to a named submatch. If no explicit location is given, the outermost node ($$) is used.

                                      func (Matcher) File

                                      func (m Matcher) File() File

                                        File returns the current file context.

                                        func (Matcher) Import

                                        func (m Matcher) Import(pkgPath string)

                                          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

                                          func (m Matcher) Match(pattern string, alternatives ...string) Matcher

                                            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) Report

                                            func (m Matcher) Report(message string) Matcher

                                              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 $$.

                                              func (Matcher) Suggest

                                              func (m Matcher) Suggest(suggestion string) Matcher

                                                Suggest assigns a quickfix suggestion for the matched code.

                                                func (Matcher) Where

                                                func (m Matcher) Where(cond bool) Matcher

                                                  Where applies additional constraint to a match. If a given cond is not satisfied, a match is rejected and rule execution stops.

                                                  type String

                                                  type String string

                                                    String represents an arbitrary string-typed data.

                                                    func (String) Matches

                                                    func (String) Matches(pattern string) bool

                                                      Matches reports whether a string matches the given regexp pattern.

                                                      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
                                                      }

                                                        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

                                                          type VarFilterContext struct {
                                                          	// Type is mapped to Var.Type field.
                                                          	Type types.Type
                                                          }

                                                            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.

                                                                func (*VarFilterContext) SizeOf

                                                                func (*VarFilterContext) SizeOf(x types.Type) int

                                                                  SizeOf returns the size of the given type. It uses the ruleguard.Context.Sizes to calculate the result.

                                                                  Directories

                                                                  Path Synopsis
                                                                  fluent module
                                                                  Package types mimics the https://golang.org/pkg/go/types/ package.
                                                                  Package types mimics the https://golang.org/pkg/go/types/ package.