class BaseCompiler

Used internally with addModuleTypeForCompilation for the manualDCE option.

A stack of ModuleTypes yet to be processed.

Used internally with addModuleTypeForCompilation for the manualDCE option.

A list of ModuleType unique identifiers that have been queued once.

This function is to be used in conjunction with the manualDCE option.

With manualDCE enabled, types encountered while compiling should be passed to this function to be added to the compilation queue.

Any repeats will NOT be re-queued, you are safe (as expected) to spam this function as much as you want.

You should essentially call this for: - The type of every variable compiled. - The type of every expression compiled. - All argument and return types for every function compiled.

Use addTypeForCompilation to pass a haxe.macro.Type instead.

Manually adds a reserved variable name that cannot be used in the output.

See addModuleTypeForCompilation.

Works the same as addModuleTypeForCompilation but takes a haxe.macro.Type instead of haxe.macro.ModuleType.

Returns false if the haxe.macro.Type couldn't be converted to haxe.macro.ModuleType.

Set the content or append it if it already exists.

priority dictates where the content is appended relative to other calls to these functions.

A function intended to be overriden by your compiler class.

Compiles the provided abstract. Defined in GenericCompiler. It ignores all abstracts by default since Haxe converts them to function calls.

A function required to be overriden by your compiler class.

Compiles the provided class. Defined in GenericCompiler. Override this to configure the behavior.

A function required to be overriden by your compiler class.

Compiles the provided enum. Defined in GenericCompiler. Override this to configure the behavior.

Compiles the Haxe metadata to the target's equivalent.

This function will always return null unless allowMetaMetadata is true or metadataTemplates contains at least one entry.

A function intended to be overriden by your compiler class.

Compiles the provided typedef. Defined in GenericCompiler. It ignores all typedefs by default since Haxe redirects all types automatically.

Compiles the provided variable name. Ensures it does not match any of the reserved variable names.

Check if an extra file exists.

A function intended to be overriden by your compiler class.

This is called once at the start of compilation.

moduleTypes is an array of ALL types supplied by the Haxe compiler. Removing (or adding?) entries from this will change what modules are sent to your compiler.

moduleTypes is a unique copy made specifically for this function, so it is safe to modify directly and return it.

To enable the exact behavior supplied by the deprecated smartDCE option, the following code can be used:

public override function filterTypes(moduleTypes: Array<ModuleType>): Array<ModuleType> {
	final tracker = new reflaxe.input.ModuleUsageTracker(moduleTypes, this);
	return tracker.filteredTypes(this.options.customStdMeta);
}

Generates the output.

A function intended to be overriden by your compiler class.

This is called once at the end of compilation if options.fileOutputType is set to Manual.

This is where you can generate your output files manually instead of relying on Reflaxe's default output system.

Files should be saved using output.saveFile(path, content)

Generates an "injection" expression if possible.

// For example:
generateInjectionExpression("const booty <= (1,2)");

// Returns a dynamically-typed `TypedExpr` for the expression:
untyped __LANG__("const booty <= (1,2)");

Used to configure how output is generated automatically.

Public getter for currentModule.

Returns the contents of the file if it exists.

priority dictates where the content is appended relative to other calls to these functions.

Returns an empty string if nothing exists.

Returns the "main" typed expression for the program.

For example, if -main MyClass is set in the project, the expression will be: MyClass.main().

Please note if using Haxe v4.2.5 or below, the main class must be defined using -D mainClass. For example: -D mainClass=MyClass.

Extracts the ModuleType of the main class based on getMainExpr function.

Given a haxe.macro.Position, generates an error at the position stating: "Could not generate expression".

Set the content or append it if it already exists.

priority dictates where the content is appended relative to other calls to these functions.

Set all the content for an arbitrary file added to the output folder.

Set all the content for a file if it doesn't exist yet.

Sets the directory files will be generated in.

Use while compiling a module type (typically through one of the BaseCompiler override methods like compileClassImpl) to set the name of the file that will contain the output being generated.

Subdirectories can be used with the forward slash.

Setting to an empty String or null will result in the file being generated in the top directory (the output directory).

Use while compiling a module type (typically through one of the BaseCompiler override methods like compileClassImpl) to set the name of the file that will contain the output being generated.

Setting to an empty String or null will result in the default file name being used.

Called before compileClass, compileEnum, etc. to set up fields to be referenced.

A function intended to be overriden by your compiler class.

This is called at the start of compilation for each class.

If false is returned, the class will not be sent to your compiler later.

A function intended to be overriden by your compiler class.

This is called at the start of compilation for each class field.

If false is returned, a ClassFuncData or ClassVarData will not be generated for the field. The field will still be accessible from the ClassType however.

A function intended to be overriden by your compiler class.

This is called at the start of compilation for each enum.

If false is returned, the enum will not be sent to your compiler later.