Code Map

module volta.ir.toplevel;


//! The toplevelest node.
class Module : Node
{
public:
	//! Name used for mangling.
	name: QualifiedName;
	//! Toplevel nodes.
	children: TopLevelBlock;
	//! Auto generated module name, unimportable.
	isAnonymous: bool;
	globalDocComments: string[];
	myScope: Scope;
	hasPhase1: bool;
	hasPhase2: bool;
	magicFlagD: bool;
	forceNoDebug: bool;
	gathered: bool;


public:
	this() { }
	this(old: Module) { }
	//! Get a unique number for this module.
	fn getId() size_t { }
}

//! A TopLevelBlock contains a series of nodes, appropriate for things like
//! modules, classes, structs, and so on.
class TopLevelBlock : Node
{
public:
	nodes: Node[];


public:
	this() { }
	this(old: TopLevelBlock) { }
}

//! An Import adds a module to the search path of identifiers inside the
//! module it's in.
class Import : Node
{
public:
	access: Access;
	isStatic: bool;
	names: QualifiedName[];
	bind: Identifier;
	aliases: Identifier[][];
	targetModules: Module[];


public:
	this() { }
	this(old: Import) { }
}

//! Attributes apply different behaviours and access levels to one or more
//! top level nodes. These are lowered onto the object by the attribremoval
//! pass.
class Attribute : Node
{
public:
	//! Used to specify the exact sort of attribute.
	enum Kind
	{
		Invalid,
		LinkageVolt,
		LinkageC,
		LinkageCPlusPlus,
		LinkageD,
		LinkageWindows,
		LinkagePascal,
		LinkageSystem,
		LoadDynamic,
		Align,
		Deprecated,
		Private,
		Protected,
		Public,
		Export,
		Static,
		Extern,
		Final,
		Synchronized,
		Override,
		Abstract,
		Const,
		Auto,
		Scope,
		Global,
		Local,
		Shared,
		Immutable,
		Inout,
		Disable,
		Property,
		Trusted,
		System,
		Safe,
		NoThrow,
		Pure,
		MangledName,
		Label,
	}


public:
	kind: Kind;
	members: TopLevelBlock;
	//! for "public abstract:"
	chain: Attribute;
	//! If kind == Annotation or MangledName.
	arguments: Exp[];
	alignAmount: i32;


public:
	this() { }
	this(old: Attribute) { }
}

//! Named is a base class for named types, like Enum, Struct, Class and so
//! on. This is slightly different from Aggregate since Enum is not a
//! Aggregate, but is a named type.
class Named : Type
{
public:
	isResolved: bool;
	access: Access;
	//! Unmangled name of the NamedType.
	name: string;
	//! Context for this NamedType.
	myScope: Scope;
	//! Filled in by the semantic pass.
	typeInfo: Variable;


public:
	this(nt: NodeType) { }
	this(nt: NodeType, old: Named) { }
}

//! Aggregate is a base class for Struct, Union & Class.
class Aggregate : Named
{
public:
	anonymousAggregates: Aggregate[];
	anonymousVars: Variable[];
	//! Toplevel nodes.
	members: TopLevelBlock;
	isActualized: bool;


public:
	this(nt: NodeType) { }
	this(nt: NodeType, old: Aggregate) { }
}

//! Plain Old Data aggregates. Struct and Union, basically.
class PODAggregate : Aggregate
{
public:
	constructors: Function[];


public:
	this(nt: NodeType) { }
	this(nt: NodeType, old: PODAggregate) { }
}

//! Java style class declaration. Classes enable polymorphism, and are
//! always accessed through opaque references (to prevent slicing -- look
//! it up!)
class Class : Aggregate
{
public:
	//! Optional.
	parent: QualifiedName;
	//! Optional.
	interfaces: QualifiedName[];
	userConstructors: Function[];
	vtableVariable: Variable;
	classinfoVariable: Variable;
	ifaceVariables: Variable[];
	initVariable: Variable;
	//! Filled in by the typeverifier.
	parentClass: Class;
	//! Filled in by the typeverifier.
	parentInterfaces: _Interface[];
	//! Filled in by the typeverifier.
	interfaceOffsets: size_t[];
	//! Filled in by the classresolver.
	methodsCache: Function[][];
	layoutStruct: Struct;
	isObject: bool;
	isAbstract: bool;
	isFinal: bool;


public:
	this() { }
	this(old: Class) { }
}

//! Java style interface declaration. An interface defines multiple
//! functions that an implementing class must define. A class can inherit
//! from multiple interfaces, and can be treated as an instance of any one
//! of them.
class _Interface : Aggregate
{
public:
	//! Super interfaces to this.
	interfaces: QualifiedName[];
	//! Filled in by the typeverifier.
	parentInterfaces: _Interface[];
	layoutStruct: Struct;


public:
	this() { }
	this(old: _Interface) { }
}

//! C style union. Structs are a POD data type, and should be binary
//! compatible with the same union as defined by your friendly
//! neighbourhood C compiler.
class Union : PODAggregate
{
public:
	totalSize: size_t;


public:
	this() { }
	this(old: Union) { }
}

//! C style struct. Structs are a POD data type, and should be binary
//! compatible with the same struct as defined by your friendly
//! neighbourhood C compiler.
class Struct : PODAggregate
{
public:
	//! If not null, this struct was lowered from this.
	loweredNode: Node;


public:
	this() { }
	this(old: Struct) { }
}

//! C style Enum. Enums create symbols that are associated with compile time
//! constants. By default, they are enumerated with ascending numbers,
//! hence the name.
class Enum : Named
{
public:
	//! At least one.
	members: EnumDeclaration[];
	base: Type;
	toSink: Function;


public:
	this() { }
	this(old: Enum) { }
}

//! Unittest code to be run on if selected by user.
class Unittest : Node
{
public:
	//! Contains statements.
	_body: BlockStatement;


public:
	this() { }
	this(old: Unittest) { }
}

//! Node represention a compile time conditional compilation.
class Condition : Node
{
public:
	//! Used to specify the exact sort of condition.
	enum Kind
	{
		Invalid,
		//! version (identifier) {}
		Version,
		//! debug {}, debug (identifier) {}
		Debug,
		//! static if (exp) {}
		StaticIf,
	}


public:
	kind: Kind;
	exp: Exp;


public:
	this() { }
	this(old: Condition) { }
}

//! Node represention a compile time conditional compilation, at the
//! toplevel. Uses Condition to specify the if it should be compiled.
class ConditionTopLevel : Node
{
public:
	condition: Condition;
	elsePresent: bool;
	members: TopLevelBlock;
	_else: TopLevelBlock;


public:
	this() { }
	this(old: ConditionTopLevel) { }
}

//! Node represention of a function mixin.
class MixinFunction : Node
{
public:
	//! Not optional.
	name: string;
	raw: BlockStatement;


public:
	this() { }
	this(old: MixinFunction) { }
}

//! Node represention of a template mixin.
class MixinTemplate : Node
{
public:
	name: string;
	raw: TopLevelBlock;


public:
	this() { }
	this(old: MixinTemplate) { }
}