stdlib

package
v0.4.1 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Aug 30, 2026 License: MIT Imports: 6 Imported by: 0

Documentation

Overview

Package stdlib describes compiler-known portable and platform packages. Definitions are semantic contracts; backends lower their intrinsic IDs to target APIs without leaking those APIs into the TypeRB source language.

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func IsReservedPath

func IsReservedPath(packagePath string) bool

func LookupReceiverMethod

func LookupReceiverMethod(receiver types.Type, name string) (*Package, Symbol, bool)

func LookupRuntimeExport added in v0.1.9

func LookupRuntimeExport(name string) (*Package, RuntimeExport, bool)

LookupRuntimeExport returns the compiler-owned package that declares name. Inferred library result types may use these declarations internally, while source annotations still require an explicit import.

func ReceiverMatches added in v0.2.3

func ReceiverMatches(pattern, actual types.Type, typeParameterNames []string) bool

ReceiverMatches reports whether a compiler-known receiver pattern applies to a checked value type. Official packages use the same matching rule as the portable standard library, while remaining unavailable until explicitly imported.

Types

type Block added in v0.2.9

type Block struct {
	Parameters      []types.Type
	ControlBoundary bool
}

Block describes the callback accepted by a compiler-owned package function. It deliberately models only ordinary callback blocks; structured control-flow blocks remain declaration-provider functionality.

type JSXProvider added in v0.2.3

type JSXProvider struct {
	Node                types.Type
	IntrinsicAttributes map[string]types.Type
}

JSXProvider declares the node and intrinsic-attribute types contributed by an explicitly imported package. Grammar remains shared while each frontend runtime owns its JSX semantics.

type Kind

type Kind string
const (
	Portable Kind = "portable"
	Platform Kind = "platform"
)

type Package

type Package struct {
	Path       string
	ModulePath string
	// Root names the public declaration that owns this package's qualified
	// operations. Its members are backed by Symbols but are not themselves
	// top-level named exports.
	Root string
	// BuiltinRoot marks the narrow compiler-owned case where Root is the
	// canonical imported static API for an existing built-in type.
	BuiltinRoot    bool
	RuntimeAlias   string
	RuntimeExports []RuntimeExport
	Source         string
	Kind           Kind
	Internal       bool
	Targets        map[string]bool
	NativeSyntax   bool
	TypeProvider   string
	JSX            *JSXProvider
	Capability     bool
	Symbols        map[string]Symbol
}

func Lookup

func Lookup(packagePath string) (*Package, bool)

func PublicPortablePackages added in v0.3.26

func PublicPortablePackages(mode string) []*Package

PublicPortablePackages returns public compiler-owned packages that authored source may import in the selected backend mode.

func RuntimeDependenciesForType added in v0.1.5

func RuntimeDependenciesForType(typ types.Type) []*Package

RuntimeDependenciesForType returns compiler-owned modules whose runtime declarations are named by a library intrinsic's result type. Source code still needs an explicit import to refer to those declarations directly.

func RuntimeExportPackages added in v0.2.3

func RuntimeExportPackages(mode string) []*Package

RuntimeExportPackages returns public portable packages that declare source- visible runtime types. Interactive tooling uses this catalog without exposing internal packages or target-specific APIs.

func (*Package) DefaultAlias

func (p *Package) DefaultAlias() string

func (*Package) Supports

func (p *Package) Supports(mode string) bool

type Parameter

type Parameter struct {
	Name     string
	Type     types.Type
	Optional bool
	Keyword  bool
	Mutable  bool
	Exact    bool
}

type RuntimeExport added in v0.1.5

type RuntimeExport struct {
	Name string
	Kind string
}

type Symbol

type Symbol struct {
	Name      string
	Intrinsic string
	// StaticOwner names the class or module that owns this compiler-known
	// operation. Unlike Receiver, it represents a static member and does not
	// pass the owner declaration as a runtime call argument.
	StaticOwner string
	// CompilerOnly keeps runner protocol operations out of user imports and
	// language-service completion while allowing compiler-owned source to use
	// the same checked package boundary.
	CompilerOnly bool
	// RuntimeIndependent marks an intrinsic that is fully lowered by every
	// backend even when its public package also provides a source wrapper.
	RuntimeIndependent  bool
	RequiredSymbols     []string
	TypeParameters      []string
	EqualityTypes       []types.Type
	OrderingTypes       []types.Type
	Receiver            types.Type
	ReceiverMutable     bool
	Parameters          []Parameter
	Return              types.Type
	Variadic            bool
	Inference           string
	RuntimeDependencies []types.Type
	Block               *Block
}

func Instantiate

func Instantiate(symbol Symbol, arguments []types.Type) Symbol

Instantiate substitutes compiler-owned type parameters inferred from call arguments. The first occurrence fixes a type variable; later occurrences are checked against that substitution by the ordinary checker.

func ReceiverMethods added in v0.1.6

func ReceiverMethods(receiver types.Type) []Symbol

ReceiverMethods returns the portable receiver methods available for a checked type. Language tooling uses the same contracts as the checker so completion cannot advertise target-native or otherwise invalid members.

func (Symbol) HasReceiver

func (s Symbol) HasReceiver() bool

func (Symbol) HasStaticOwner added in v0.4.1

func (s Symbol) HasStaticOwner() bool

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL