thriftrw: go.uber.org/thriftrw/ast Index | Files

package ast

import "go.uber.org/thriftrw/ast"

Package ast provides types and intefaces representing the abstract syntax tree for a single .thrift file.

Docstrings

Types which have a Doc field support parsing docstrings in the form, "/** ... */". For example, given the following,

/**
 * Name of the user who composed this message.
 *
 * If unset, the comment was posted by an anonymous user.
 */
1: optional string author

The Doc of the parsed Field will be,

Name of the user who composed this message.

If unset, the comment was posted by an anonymous user.

Index

Package Files

annotation.go basetypeid_string.go constant.go definition.go doc.go header.go line_no.go node.go program.go type.go visitor.go walk.go

func FormatAnnotations Uses

func FormatAnnotations(anns []*Annotation) string

FormatAnnotations formats a collection of annotations into a string.

func LineNumber Uses

func LineNumber(n Node) int

LineNumber returns the line in the file at which the given node was defined or 0 if the Node does not record its line number.

func Walk Uses

func Walk(v Visitor, n Node)

Walk walks the AST depth-first with the given visitor, starting at the given node. The visitor's Visit function should return a non-nil visitor if it wants to visit the children of the node it was called with.

type Annotation Uses

type Annotation struct {
    Name  string
    Value string
    Line  int
}

Annotation represents a type annotation. Type annotations are key-value pairs in the form,

(foo = "bar", baz = "qux")

They may be used to customize the generated code. Annotations are optional anywhere in the code where they're accepted and may be skipped completely.

func (*Annotation) String Uses

func (ann *Annotation) String() string

type BaseType Uses

type BaseType struct {
    // ID of the base type.
    ID  BaseTypeID

    // Type annotations associated with this reference.
    Annotations []*Annotation
    Line        int
}

BaseType is a reference to a Thrift base type.

bool, byte, i16, i32, i64, double, string, binary

All references to base types in the document may be followed by type annotations.

bool (go.type = "int")

func (BaseType) String Uses

func (bt BaseType) String() string

type BaseTypeID Uses

type BaseTypeID int

BaseTypeID is an identifier for primitive types supported by Thrift.

const (
    BoolTypeID   BaseTypeID = iota + 1 // bool
    I8TypeID                           // byte/i8
    I16TypeID                          // i16
    I32TypeID                          // i32
    I64TypeID                          // i64
    DoubleTypeID                       // double
    StringTypeID                       // string
    BinaryTypeID                       // binary
)

IDs of the base types supported by Thrift.

func (BaseTypeID) String Uses

func (i BaseTypeID) String() string

type Constant Uses

type Constant struct {
    Name  string
    Type  Type
    Value ConstantValue
    Line  int
    Doc   string
}

Constant is a constant declared in the Thrift file using a const statement.

const i32 foo = 42

func (*Constant) Info Uses

func (c *Constant) Info() DefinitionInfo

Info for Constant

type ConstantBoolean Uses

type ConstantBoolean bool

ConstantBoolean is a boolean value specified in the Thrift file.

true
false

type ConstantDouble Uses

type ConstantDouble float64

ConstantDouble is a floating point value specified in the Thrift file.

1.234

type ConstantInteger Uses

type ConstantInteger int64

ConstantInteger is an integer value specified in the Thrift file.

42

type ConstantList Uses

type ConstantList struct {
    Items []ConstantValue
    Line  int
}

ConstantList is a list literal from the Thrift file.

[1, 2, 3]

type ConstantMap Uses

type ConstantMap struct {
    Items []ConstantMapItem
    Line  int
}

ConstantMap is a map literal from the Thrift file.

{"a": 1, "b": 2}

Note that map literals can also be used to build structs.

type ConstantMapItem Uses

type ConstantMapItem struct {
    Key, Value ConstantValue
    Line       int
}

ConstantMapItem is a single item in a ConstantMap.

type ConstantReference Uses

type ConstantReference struct {
    // Name of the referenced value.
    Name string

    // Line number on which this reference was made.
    Line int
}

ConstantReference is a reference to another constant value defined in the Thrift file.

foo.bar

type ConstantString Uses

type ConstantString string

ConstantString is a string literal specified in the Thrift file.

"hello world"

type ConstantValue Uses

type ConstantValue interface {
    Node
    // contains filtered or unexported methods
}

ConstantValue unifies the different types representing constant values in Thrift files.

type Definition Uses

type Definition interface {
    Node

    Info() DefinitionInfo
    // contains filtered or unexported methods
}

Definition unifies the different types representing items defined in the Thrift file.

type DefinitionInfo Uses

type DefinitionInfo struct {
    Name string
    Line int
}

DefinitionInfo provides a common way to access name and line information for definitions.

type Enum Uses

type Enum struct {
    Name        string
    Items       []*EnumItem
    Annotations []*Annotation
    Line        int
    Doc         string
}

Enum is a set of named integer values.

enum Status { Enabled, Disabled }

enum Role {
	User = 1,
	Moderator = 2 (py.name = "Mod"),
	Admin = 3
} (go.name = "UserRole")

func (*Enum) Info Uses

func (e *Enum) Info() DefinitionInfo

Info for Enum.

type EnumItem Uses

type EnumItem struct {
    Name string
    // Value of the item. This is nil if the user did not specify anything.
    Value       *int
    Annotations []*Annotation
    Line        int
    Doc         string
}

EnumItem is a single item in an Enum definition.

type Field Uses

type Field struct {
    ID           int
    Name         string
    Type         Type
    Requiredness Requiredness
    Default      ConstantValue
    Annotations  []*Annotation
    Line         int
    Doc          string
}

Field is a single field inside a struct, union, exception, or a single item in the parameter or exception list of a function.

1: required i32 foo = 0
2: optional binary (max_length = "4096") bar
3: i64 baz (go.name = "qux")

type Function Uses

type Function struct {
    Name        string
    Parameters  []*Field
    ReturnType  Type
    Exceptions  []*Field
    OneWay      bool
    Annotations []*Annotation
    Line        int
    Doc         string
}

Function is a single function inside a service.

binary getValue(1: string key)
	throws (1: KeyNotFoundError notFound) (
		ttl.milliseconds = "250"
	)
type Header interface {
    Node

    Info() HeaderInfo
    // contains filtered or unexported methods
}

Header unifies types representing header in the AST.

type HeaderInfo Uses

type HeaderInfo struct {
    Line int
}

HeaderInfo provides a common way to access the line for a header.

type Include Uses

type Include struct {
    Path string
    Name string
    Line int
}

Include is a request to include another Thrift file.

include "shared.thrift"

thriftrw's custom Include-As syntax may be used to change the name under which the file is imported.

include t "shared.thrift"

func (*Include) Info Uses

func (i *Include) Info() HeaderInfo

Info for Include.

type ListType Uses

type ListType struct {
    ValueType   Type
    Annotations []*Annotation
    Line        int
}

ListType is a reference to the Thrift list type.

list<a>

All references to list types may be followed by type annotations.

list<i64> (cpp.type = "vector")

func (ListType) String Uses

func (lt ListType) String() string

type MapType Uses

type MapType struct {
    KeyType, ValueType Type
    Annotations        []*Annotation
    Line               int
}

MapType is a reference to a the Thrift map type.

map<k, v>

All references to map types may be followed by type annotations.

map<string, list<i32>> (java.type = "MultiMap")

func (MapType) String Uses

func (mt MapType) String() string

type Namespace Uses

type Namespace struct {
    Scope string
    Name  string
    Line  int
}

Namespace statements allow users to choose the package name used by the generated code in certain languages.

namespace py foo.bar

func (*Namespace) Info Uses

func (n *Namespace) Info() HeaderInfo

Info for Namespace.

type Node Uses

type Node interface {
    // contains filtered or unexported methods
}

Node is a single element in the Thrift AST.

In addition to all Header, ConstantValue, Type, and Definition types, the following types are also AST nodes: *Annotation, ConstantMapItem, *EnumItem, *Field, *Function, *Program.

type Program Uses

type Program struct {
    Headers     []Header
    Definitions []Definition
}

Program represents the full syntax tree for a single .thrift file.

type Requiredness Uses

type Requiredness int

Requiredness represents whether a field was marked as required or optional, or if the user did not specify either.

const (
    Unspecified Requiredness = iota // unspecified (default)
    Required                        // required
    Optional                        // optional
)

Different requiredness levels that are supported.

type Service Uses

type Service struct {
    Name      string
    Functions []*Function
    // Reference to the parent service if this service inherits another
    // service, nil otherwise.
    Parent      *ServiceReference
    Annotations []*Annotation
    Line        int
    Doc         string
}

Service is a collection of functions.

service KeyValue {
	void setValue(1: string key, 2: binary value)
	binary getValue(1: string key)
} (router.serviceName = "key_value")

func (*Service) Info Uses

func (s *Service) Info() DefinitionInfo

Info for Service.

type ServiceReference Uses

type ServiceReference struct {
    Name string
    Line int
}

ServiceReference is a reference to another service.

type SetType Uses

type SetType struct {
    ValueType   Type
    Annotations []*Annotation
    Line        int
}

SetType is a reference to the Thrift set type.

set<a>

All references to set types may be followed by type annotations.

set<string> (js.type = "list")

func (SetType) String Uses

func (st SetType) String() string

type Struct Uses

type Struct struct {
    Name        string
    Type        StructureType
    Fields      []*Field
    Annotations []*Annotation
    Line        int
    Doc         string
}

Struct is a collection of named fields with different types.

This type encompasses structs, unions, and exceptions.

struct User {
	1: required string name (min_length = "3")
	2: optional Status status = Enabled;
}

struct i128 {
	1: required i64 high
	2: required i64 low
} (py.serializer = "foo.Int128Serializer")

union Contents {
	1: string plainText
	2: binary pdf
}

exception ServiceError { 1: required string message }

func (*Struct) Info Uses

func (s *Struct) Info() DefinitionInfo

Info for Struct.

type StructureType Uses

type StructureType int

StructureType specifies whether a struct-like type is a struct, union, or exception.

const (
    StructType    StructureType = iota + 1 // struct
    UnionType                              // union
    ExceptionType                          // exception
)

Different kinds of struct-like objects supported by us.

type Type Uses

type Type interface {
    Node
    fmt.Stringer
    // contains filtered or unexported methods
}

Type unifies the different types representing Thrift field types.

type TypeReference Uses

type TypeReference struct {
    Name string
    Line int
}

TypeReference references a user-defined type.

func (TypeReference) String Uses

func (tr TypeReference) String() string

type Typedef Uses

type Typedef struct {
    Name        string
    Type        Type
    Annotations []*Annotation
    Line        int
    Doc         string
}

Typedef is used to define an alias for another type.

typedef string UUID
typedef i64 Timestamp (unit = "milliseconds")

func (*Typedef) Info Uses

func (t *Typedef) Info() DefinitionInfo

Info for Typedef.

type Visitor Uses

type Visitor interface {
    Visit(w Walker, n Node) Visitor
}

Visitor walks an AST. The Visit function is called on each node of the AST. If the function returns a non-nil visitor for any node, that visitor is called on the chilren of that node.

func MultiVisitor Uses

func MultiVisitor(visitors ...Visitor) Visitor

MultiVisitor merges the given visitors into a single Visitor.

type VisitorFunc Uses

type VisitorFunc func(Walker, Node)

VisitorFunc is a Visitor which visits all the nodes of the AST.

func (VisitorFunc) Visit Uses

func (f VisitorFunc) Visit(w Walker, n Node) Visitor

Visit the given node and its descendants.

type Walker Uses

type Walker interface {
    // Ancestors returns a copy of a slice containing all the ancestor nodes
    // of the current node. The first node in the slice is the immediate
    // parent of the current node, the node after that its parent, and so on.
    Ancestors() []Node

    // Parent returns the parent node of the current node or nil if this node
    // does not have a parent node.
    Parent() Node
}

Walker provides acccess to information about the state of the AST walker.

Package ast imports 3 packages (graph) and is imported by 18 packages. Updated 2020-01-07. Refresh now. Tools for package owners.