cache

Documentation

Index

• type CSSCache
  • func (c *CSSCache) Parse(log logger.Log, source logger.Source, options css_parser.Options) css_ast.AST
• type CacheSet
  • func MakeCacheSet() *CacheSet
• type FSCache
  • func (c *FSCache) ReadFile(fs fs.FS, path string) (contents string, canonicalError error, originalError error)
• type JSCache
  • func (c *JSCache) Parse(log logger.Log, source logger.Source, options js_parser.Options) (js_ast.AST, bool)
• type JSONCache
  • func (c *JSONCache) Parse(log logger.Log, source logger.Source, options js_parser.JSONOptions) (js_ast.Expr, bool)
• type SourceIndexCache
  • func (c *SourceIndexCache) Get(path logger.Path, kind SourceIndexKind) uint32
  • func (c *SourceIndexCache) GetGlob(parentSourceIndex uint32, globIndex uint32) uint32
  • func (c *SourceIndexCache) LenHint() uint32
• type SourceIndexKind

Types

type CSSCache

type CSSCache struct {
	// contains filtered or unexported fields
}

func (*CSSCache) Parse

func (c *CSSCache) Parse(log logger.Log, source logger.Source, options css_parser.Options) css_ast.AST

type CacheSet

type CacheSet struct {
	FSCache          FSCache
	CSSCache         CSSCache
	JSONCache        JSONCache
	JSCache          JSCache
	SourceIndexCache SourceIndexCache
}

This is a cache of the parsed contents of a set of files. The idea is to be able to reuse the results of parsing between builds and make subsequent builds faster by avoiding redundant parsing work. This only works if:

• The AST information in the cache must be considered immutable. There is no way to enforce this in Go, but please be disciplined about this. The ASTs are shared in between builds. Any information that must be mutated in the AST during a build must be done on a shallow clone of the data if the mutation happens after parsing (i.e. a clone that clones everything that will be mutated and shares only the parts that won't be mutated).

• The information in the cache must not depend at all on the contents of any file other than the file being cached. Invalidating an entry in the cache does not also invalidate any entries that depend on that file, so caching information that depends on other files can result in incorrect results due to reusing stale data. For example, do not "bake in" some value imported from another file.

• Cached ASTs must only be reused if the parsing options are identical between builds. For example, it would be bad if the AST parser depended on options inherited from a nearby "package.json" file but those options were not part of the cache key. Then the cached AST could incorrectly be reused even if the contents of that "package.json" file have changed.

func MakeCacheSet

func MakeCacheSet() *CacheSet

type FSCache

type FSCache struct {
	// contains filtered or unexported fields
}

func (*FSCache) ReadFile

func (c *FSCache) ReadFile(fs fs.FS, path string) (contents string, canonicalError error, originalError error)

type JSCache

type JSCache struct {
	// contains filtered or unexported fields
}

func (*JSCache) Parse

func (c *JSCache) Parse(log logger.Log, source logger.Source, options js_parser.Options) (js_ast.AST, bool)

type JSONCache

type JSONCache struct {
	// contains filtered or unexported fields
}

func (*JSONCache) Parse

func (c *JSONCache) Parse(log logger.Log, source logger.Source, options js_parser.JSONOptions) (js_ast.Expr, bool)

type SourceIndexCache

type SourceIndexCache struct {
	// contains filtered or unexported fields
}

func (*SourceIndexCache) Get

func (c *SourceIndexCache) Get(path logger.Path, kind SourceIndexKind) uint32

func (*SourceIndexCache) GetGlob

func (c *SourceIndexCache) GetGlob(parentSourceIndex uint32, globIndex uint32) uint32

func (*SourceIndexCache) LenHint

func (c *SourceIndexCache) LenHint() uint32

type SourceIndexKind

type SourceIndexKind uint8

const (
	SourceIndexNormal SourceIndexKind = iota
	SourceIndexJSStubForCSS
)