Sandbox.Compiling

The name of the compiler

The compiler's configuration settings

The syntax trees that should be compiled

Hashes of source files, used for incremental compiles. Not serialized right now.

Represents a file to send to the compiler along with all the code. This is usually something that the generator turns into code, such as a Razor file.

Additional files that the compiler/generator needs. This is going to be .razor files.

Converts the syntax tree paths from physical paths to project local paths

References that this compiler/generator needs to compile the code

The version of the code archive 1005 - Inital version 1006 - Razor updates. Add razor namespaces on older versions. 1007 - Razor changed to our own Microsoft.AspNetCore.Components assembly

If true then we shouldn't automatically add @namespace to razor output, we shouldn't use the folder namespace structure.

Serialize to a byte array

Deserialize from a byte array

Build notifications start of suppressed until after startup proper. That way we don't get 4 build notification windows popping up on startup.

The compilers within the group

The name of this compile group, for debugging/display purposes

Returns true if we have compiles pending

Returns true if we are currently in the process of building

True if we want to print errors in the console when compiling

True if we want to use fast hotloading with this compile group

Returns true if build was successful

Called when a compiling starts

Called when a compiling ends

Called when a compile completes successfully. Can access the result from BuildResult.

All created compilers.

Compilers waiting for recompile

Allows providing an external way to find references

AccessControl instance to use when verifying whitelist. Must be set to enable compile-time access control.

Shut everything down

Create a new compiler in this group.

Mark this assembly as changed.

Returns true if this group will compile next build.

Recompile anything that depends on us too

Build the compilers

Find a reference for this dll. Throws if a reference is not found / invalid, and returns if a reference should be silently ignored (like self-referencing).

Reset the compile group. Clear errors and outputs.

Allows you to look up references for a compiler.

Find a reference for this dll

Given a folder of .cs files, this will produce (and load) an assembly

If true, we will be using the whitelist system. If false then this package won't be "sandboxed", so won't be able to be published on the platform.

If true, we'll compile with /unsafe. This means that the package won't be able to be published on the platform.

The current release mode. This only matters during local development. Published games are always built in release mode, where optimizations are enabled and debugging is limited (breakpoints, sequence points, and locals may be unavailable).

References to non-package assemblies, by assembly name.

Maps file patterns to preprocessor directives they should be wrapped in

Strips disabled text trivia from the syntax tree. This is stuff like `#if false` blocks that are not compiled.

Folders to ignore when walking the tree

Each unique element of

Fetches the preprocessor symbols, which might've changed based on criteria

Returns the CSharpParseOptions for this configuration, which includes the preprocessor symbols defined in .

Task completed at the end of , for other compilers to await if they reference this one.

Fill this compiler from a code archive

Called by before a build starts. Prepares this compiler to be referenced by other compilers before they build with .

Build and load the assembly.

Each compiler must belong to a compile group

The output from the previous build

Is this compiler currently building?

Returns true if this compiler is pending a build, or currently building.

Name of the project this compiler was created for. This could be something like "base" or "org.ident".

During development we use absolute source paths so that debugging works better. In a packed/release build it's good to use relative paths instead, just to avoid exposing the builder's file system.

A list of warnings and errors created by the last build

Generated assembly name, without an extension. This will be "package.{Name}".

Global namespaces

Directories to search for code

An aggregate of all the filesystem this compiler has

After compile is completed successfully this will be non null.

Keeps track of the most recent values, in case the current one is revoked because it was fast-hotloaded. This dictionary is cleared when a version is built that doesn't support fast hotload at all.

The compiler's settings.

Should only ever get called from CompileGroup.

Add an extra source path. Useful for situations where you want to combine multiple addons into one.

Results for the assembly build. This can contain warnings or errors.

Accesses Output.Successful

Keep tabs of how many times we've compiled

Read text from a file while dealing with the fact that it might be being saved right when we're loading it so it's likely to throw IOExceptions.

Waits for the current build to finish, then outputs that build's result. This is only valid during .

Return this compiler and all child compilers

Recompile this as soon as is appropriate

Process Razor files from the code archive and generate C# syntax trees

References needed for compile

Add a reference to this compiler. This might be a system dll, or an assembly name from a fellow compiler.

Returns true if contains the given reference assembly name. If is true, referenced compilers are searched too.

Generated file that will get stuff like global usings and assembly attributes.

Collect all of the code that should compiled into this assembly

Strips out disabled text trivia from the syntax tree. This is stuff like `#if false` blocks that are not compiled.

Check if a file should be wrapped in conditional compilation directives

Watch the filesystem for changes to our c# files, and trigger a recompile if they change.

True if the build succeeded

The compiler that has produced this build

The version of the assembly

The [assembly].dll contents for this build

A code archive created during the compile

The [assembly].xml contents for this build

A list of diagnostics caused by the previous build

If an exception happened during the build, it'll be available here

For referencing this assembly from another compiler.

Visits every node type, unless that node type has been explicitly overridden. This gives us complete coverage of every type of possible syntax node. From there we can see if it references any blacklisted symbols.

Holds state for incremental compilation. Ask Matt or James to add comments, I don't know.

Loads the framework assemblies from the bin/ref folder and makes them available globally to every compiler.

Find a framework reference by its assembly name