internal static Assembly[] GetAssemblies(EditorCompilation editorCompilation)
{
ScriptAssembly[] allEditorScriptAssemblies = editorCompilation.GetAllEditorScriptAssemblies();
Assembly[] array = new Assembly[allEditorScriptAssemblies.Length];
Dictionary <ScriptAssembly, Assembly> scriptAssemblyToAssembly = new Dictionary <ScriptAssembly, Assembly>();
for (int i = 0; i < allEditorScriptAssemblies.Length; i++)
{
scriptAssemblyToAssembly.Add(allEditorScriptAssemblies[i], array[i]);
}
for (int j = 0; j < allEditorScriptAssemblies.Length; j++)
{
ScriptAssembly scriptAssembly = allEditorScriptAssemblies[j];
string assemblyNameWithoutExtension = AssetPath.GetAssemblyNameWithoutExtension(scriptAssembly.Filename);
string fullPath = scriptAssembly.FullPath;
string[] files = scriptAssembly.Files;
string[] defines = scriptAssembly.Defines;
string[] references = scriptAssembly.References;
Assembly[] assemblyReferences = (from a in scriptAssembly.ScriptAssemblyReferences
select scriptAssemblyToAssembly[a]).ToArray <Assembly>();
AssemblyFlags assemblyFlags = AssemblyFlags.None;
if ((scriptAssembly.Flags & UnityEditor.Scripting.ScriptCompilation.AssemblyFlags.EditorOnly) == UnityEditor.Scripting.ScriptCompilation.AssemblyFlags.EditorOnly)
{
assemblyFlags |= AssemblyFlags.EditorAssembly;
}
array[j] = new Assembly(assemblyNameWithoutExtension, fullPath, files, defines, assemblyReferences, references, assemblyFlags);
}
return(array);
}
internal bool Build(EditorCompilation editorCompilation)
{
if (editorCompilation.IsCompilationTaskCompiling())
{
return(false);
}
if (status != AssemblyBuilderStatus.NotStarted)
{
throw new Exception(string.Format("Cannot start AssemblyBuilder with status {0}. Expected {1}", status, AssemblyBuilderStatus.NotStarted));
}
var scriptAssembly = editorCompilation.CreateScriptAssembly(this);
compilationTask = new CompilationTask(new ScriptAssembly[] { scriptAssembly }, scriptAssembly.OutputDirectory,
EditorScriptCompilationOptions.BuildingEmpty, CompilationTaskOptions.StopOnFirstError, 1);
compilationTask.OnCompilationStarted += (assembly, phase) =>
{
editorCompilation.InvokeAssemblyCompilationStarted(assemblyPath);
OnCompilationStarted(assembly, phase);
};
compilationTask.OnCompilationFinished += (assembly, messages) =>
{
editorCompilation.InvokeAssemblyCompilationFinished(assemblyPath, messages);
OnCompilationFinished(assembly, messages);
};
compilationTask.Poll();
editorCompilation.AddAssemblyBuilder(this);
return(true);
}
internal bool Build(EditorCompilation editorCompilation)
{
bool result;
if (editorCompilation.IsCompilationTaskCompiling())
{
result = false;
}
else
{
if (this.status != AssemblyBuilderStatus.NotStarted)
{
throw new Exception(string.Format("Cannot start AssemblyBuilder with status {0}. Expected {1}", this.status, AssemblyBuilderStatus.NotStarted));
}
ScriptAssembly scriptAssembly = editorCompilation.CreateScriptAssembly(this);
this.compilationTask = new CompilationTask(new ScriptAssembly[]
{
scriptAssembly
}, scriptAssembly.OutputDirectory, EditorScriptCompilationOptions.BuildingEmpty, 1);
this.compilationTask.OnCompilationStarted += delegate(ScriptAssembly assembly, int phase)
{
editorCompilation.InvokeAssemblyCompilationStarted(this.assemblyPath);
this.OnCompilationStarted(assembly, phase);
};
this.compilationTask.OnCompilationFinished += delegate(ScriptAssembly assembly, List <UnityEditor.Scripting.Compilers.CompilerMessage> messages)
{
editorCompilation.InvokeAssemblyCompilationFinished(this.assemblyPath, messages);
this.OnCompilationFinished(assembly, messages);
};
this.compilationTask.Poll();
editorCompilation.AddAssemblyBuilder(this);
result = true;
}
return(result);
}
internal static void SubscribeToEvents(EditorCompilation editorCompilation)
{
editorCompilation.assemblyCompilationStarted += (assemblyPath) =>
{
try
{
if (assemblyCompilationStarted != null)
{
assemblyCompilationStarted(assemblyPath);
}
}
catch (Exception e)
{
UnityEngine.Debug.LogException(e);
}
};
editorCompilation.assemblyCompilationFinished += (assemblyPath, messages) =>
{
try
{
if (assemblyCompilationFinished != null)
{
assemblyCompilationFinished(assemblyPath, messages);
}
}
catch (Exception e)
{
UnityEngine.Debug.LogException(e);
}
};
}
internal static void SubscribeToEvents(EditorCompilation editorCompilation)
{
editorCompilation.assemblyCompilationStarted += delegate(string assemblyPath)
{
try
{
if (CompilationPipeline.assemblyCompilationStarted != null)
{
CompilationPipeline.assemblyCompilationStarted(assemblyPath);
}
}
catch (Exception exception)
{
Debug.LogException(exception);
}
};
editorCompilation.assemblyCompilationFinished += delegate(string assemblyPath, CompilerMessage[] messages)
{
try
{
if (CompilationPipeline.assemblyCompilationFinished != null)
{
CompilationPipeline.assemblyCompilationFinished(assemblyPath, messages);
}
}
catch (Exception exception)
{
Debug.LogException(exception);
}
};
}
internal static string[] GetPrecompiledAssemblyNames(EditorCompilation editorCompilation)
{
return(editorCompilation.GetAllPrecompiledAssemblies()
.Where(x => (x.Flags & sc.AssemblyFlags.UserAssembly) == sc.AssemblyFlags.UserAssembly)
.Select(x => AssetPath.GetFileName(x.Path))
.Distinct()
.ToArray());
}
internal static string GetAssemblyDefinitionFilePathFromScriptPath(EditorCompilation editorCompilation, string sourceFilePath)
{
if (editorCompilation.TryFindCustomScriptAssemblyFromScriptPath(sourceFilePath, out var customScriptAssembly))
{
return(customScriptAssembly.FilePath);
}
return(null);
}
internal static string GetAssemblyDefinitionFilePathFromAssemblyReference(EditorCompilation editorCompilation, string reference)
{
if (editorCompilation.TryFindCustomScriptAssemblyFromAssemblyReference(reference, out var customScriptAssembly))
{
return(customScriptAssembly.FilePath);
}
return(null);
}
internal static string[] GetDefinesFromAssemblyName(EditorCompilation editorCompilation, string assemblyName)
{
try
{
var assembly = editorCompilation.GetCustomTargetAssemblyFromName(assemblyName);
return(assembly?.Defines);
}
catch (ArgumentException)
{
return(null);
}
}
internal static Assembly[] GetPlayerAssemblies(EditorCompilation editorCompilation, EditorScriptCompilationOptions options, string[] defines)
{
var group = EditorUserBuildSettings.activeBuildTargetGroup;
var target = EditorUserBuildSettings.activeBuildTarget;
PrecompiledAssembly[] unityAssemblies = InternalEditorUtility.GetUnityAssemblies(false, group, target);
PrecompiledAssembly[] precompiledAssemblies = InternalEditorUtility.GetPrecompiledAssemblies(false, group, target);
var scriptAssemblies = editorCompilation.GetAllScriptAssemblies(options, unityAssemblies, precompiledAssemblies, defines);
return(ToAssemblies(scriptAssemblies));
}
internal static string GetAssemblyNameFromScriptPath(EditorCompilation editorCompilation, string sourceFilePath)
{
try
{
var targetAssembly = editorCompilation.GetTargetAssembly(sourceFilePath);
return(targetAssembly.Name);
}
catch (Exception)
{
return(null);
}
}
internal static string GetAssemblyRootNamespaceFromScriptPath(EditorCompilation editorCompilation, string projectRootNamespace, string sourceFilePath)
{
try
{
var csa = editorCompilation.FindCustomScriptAssemblyFromScriptPath(sourceFilePath);
return(csa != null ? (csa.RootNamespace ?? projectRootNamespace) : projectRootNamespace);
}
catch (Exception)
{
return(null);
}
}
internal static string GetAssemblyDefinitionFilePathFromAssemblyName(EditorCompilation editorCompilation, string assemblyName)
{
try
{
var customScriptAssembly = editorCompilation.FindCustomScriptAssemblyFromAssemblyName(assemblyName);
return(customScriptAssembly.FilePath);
}
catch (Exception)
{
return(null);
}
}
internal static string GetAssemblyDefinitionFilePathFromScriptPath(EditorCompilation editorCompilation, string sourceFilePath)
{
try
{
var customScriptAssembly = editorCompilation.FindCustomScriptAssemblyFromScriptPath(sourceFilePath);
return(customScriptAssembly != null ? customScriptAssembly.FilePath : null);
}
catch (Exception)
{
return(null);
}
}
internal static string GetAssemblyNameFromScriptPath(EditorCompilation editorCompilation, string sourceFilePath)
{
string result;
try
{
result = editorCompilation.GetTargetAssembly(sourceFilePath).Name;
}
catch (Exception)
{
result = null;
}
return(result);
}
private void InvokeBuildFinished(BeeDriverResult result)
{
activeBeeBuild.editorCompilation.ProcessCompilationResult(activeBeeBuild.assemblies, result, false, this);
try
{
buildFinished?.Invoke(assemblyPath, EditorCompilation.ConvertCompilerMessages(BeeScriptCompilation
.ParseAllResultsIntoCompilerMessages(result.BeeDriverMessages, result.NodeResults, EditorCompilationInterface.Instance)
.SelectMany(a => a).ToArray()));
}
catch (Exception e)
{
UnityEngine.Debug.LogException(e);
}
}
internal static void SubscribeToEvents(EditorCompilation editorCompilation)
{
editorCompilation.compilationStarted += (context) =>
{
try
{
compilationStarted?.Invoke(context);
}
catch (Exception e)
{
UnityEngine.Debug.Log(e);
}
};
editorCompilation.compilationFinished += (context) =>
{
try
{
compilationFinished?.Invoke(context);
}
catch (Exception e)
{
UnityEngine.Debug.Log(e);
}
};
editorCompilation.assemblyCompilationFinished += (scriptAssembly, messages) =>
{
try
{
#pragma warning disable 618
assemblyCompilationStarted?.Invoke(scriptAssembly.FullPath);
#pragma warning restore 618
}
catch (Exception e)
{
UnityEngine.Debug.LogException(e);
}
try
{
assemblyCompilationFinished?.Invoke(scriptAssembly.FullPath, messages);
}
catch (Exception e)
{
UnityEngine.Debug.LogException(e);
}
};
}
private void OnCompilationFinished(ScriptAssembly assembly, List <UnityEditor.Scripting.Compilers.CompilerMessage> messages)
{
if (this.buildFinished != null)
{
CompilerMessage[] arg = EditorCompilation.ConvertCompilerMessages(messages);
try
{
this.buildFinished(this.assemblyPath, arg);
}
catch (Exception exception)
{
Debug.LogException(exception);
}
}
}
internal static string GetAssemblyDefinitionFilePathFromAssemblyName(EditorCompilation editorCompilation, string assemblyName)
{
string result;
try
{
CustomScriptAssembly customScriptAssembly = editorCompilation.FindCustomScriptAssemblyFromAssemblyName(assemblyName);
result = customScriptAssembly.FilePath;
}
catch (Exception)
{
result = null;
}
return(result);
}
internal static string GetAssemblyDefinitionFilePathFromScriptPath(EditorCompilation editorCompilation, string sourceFilePath)
{
string result;
try
{
CustomScriptAssembly customScriptAssembly = editorCompilation.FindCustomScriptAssemblyFromScriptPath(sourceFilePath);
result = ((customScriptAssembly == null) ? null : customScriptAssembly.FilePath);
}
catch (Exception)
{
result = null;
}
return(result);
}
internal bool Build(EditorCompilation editorCompilation)
{
if (editorCompilation.IsCompilationTaskCompiling() ||
editorCompilation.IsAnyAssemblyBuilderCompiling())
{
return(false);
}
if (status != AssemblyBuilderStatus.NotStarted)
{
throw new Exception(string.Format("Cannot start AssemblyBuilder with status {0}. Expected {1}", status, AssemblyBuilderStatus.NotStarted));
}
var assembly = editorCompilation.CreateScriptAssembly(this);
var assemblies = assembly.AllRecursiveScripAssemblyReferencesIncludingSelf().ToArray();
// Start clean everytime
const string beeAssemblyBuilderDirectory = "Library/BeeAssemblyBuilder";
string beeAssemblyBuilderDirectoryInProjectDirectory =
string.IsNullOrEmpty(editorCompilation.projectDirectory)
? beeAssemblyBuilderDirectory
: Path.Combine(editorCompilation.projectDirectory, beeAssemblyBuilderDirectory);
if (Directory.Exists(beeAssemblyBuilderDirectoryInProjectDirectory))
{
Directory.Delete(beeAssemblyBuilderDirectoryInProjectDirectory, true);
}
var debug = compilerOptions.CodeOptimization == CodeOptimization.Debug;
var buildRequest = UnityBeeDriver.BuildRequestFor(EditorCompilation.ScriptCompilationBuildProgram, editorCompilation, $"{(int)assembly.BuildTarget}{"AB"}", beeAssemblyBuilderDirectory);
buildRequest.DataForBuildProgram.Add(() => BeeScriptCompilation.ScriptCompilationDataFor(editorCompilation, assemblies, debug, assembly.OutputDirectory, assembly.BuildTarget, true));
buildRequest.Target = Constants.ScriptAssembliesTarget;
activeBeeBuild = new BeeScriptCompilationState
{
assemblies = new[] { assembly },
ActiveBuild = BeeDriver.BuildAsync(buildRequest),
editorCompilation = editorCompilation,
};
editorCompilation.AddAssemblyBuilder(this);
InvokeBuildStarted();
return(true);
}
void OnCompilationFinished(ScriptAssembly assembly, List <UnityEditor.Scripting.Compilers.CompilerMessage> messages)
{
if (buildFinished == null)
{
return;
}
var convertedMessages = EditorCompilation.ConvertCompilerMessages(messages);
try
{
buildFinished(assemblyPath, convertedMessages);
}
catch (Exception e)
{
UnityEngine.Debug.LogException(e);
}
}
internal static Assembly[] GetAssemblies(EditorCompilation editorCompilation, EditorScriptCompilationOptions additionalOptions)
{
var scriptAssemblies = editorCompilation.GetAllEditorScriptAssemblies(additionalOptions);
var assemblies = new Assembly[scriptAssemblies.Length];
var scriptAssemblyToAssembly = new Dictionary <ScriptAssembly, Assembly>();
for (int i = 0; i < scriptAssemblies.Length; ++i)
{
scriptAssemblyToAssembly.Add(scriptAssemblies[i], assemblies[i]);
}
for (int i = 0; i < scriptAssemblies.Length; ++i)
{
var scriptAssembly = scriptAssemblies[i];
var name = AssetPath.GetAssemblyNameWithoutExtension(scriptAssembly.Filename);
var outputPath = scriptAssembly.FullPath;
var sourceFiles = scriptAssembly.Files;
var defines = scriptAssembly.Defines;
var compiledAssemblyReferences = scriptAssembly.References;
var assemblyReferences = scriptAssembly.ScriptAssemblyReferences.Select(a => scriptAssemblyToAssembly[a]).ToArray();
var flags = AssemblyFlags.None;
if ((scriptAssembly.Flags & sc.AssemblyFlags.EditorOnly) == sc.AssemblyFlags.EditorOnly)
{
flags |= AssemblyFlags.EditorAssembly;
}
var compilerOptions = scriptAssembly.CompilerOptions;
assemblies[i] = new Assembly(name,
outputPath,
sourceFiles,
defines,
assemblyReferences,
compiledAssemblyReferences,
flags,
compilerOptions);
}
return(assemblies);
}
internal static Assembly[] GetAssemblies(EditorCompilation editorCompilation, AssembliesType assembliesType)
{
var options = EditorCompilationInterface.GetAdditionalEditorScriptCompilationOptions();
switch (assembliesType)
{
case AssembliesType.Editor:
return(GetEditorAssemblies(editorCompilation, options | EditorScriptCompilationOptions.BuildingIncludingTestAssemblies, null));
case AssembliesType.Player:
return(GetPlayerAssemblies(editorCompilation, options | EditorScriptCompilationOptions.BuildingIncludingTestAssemblies, null));
case AssembliesType.PlayerWithoutTestAssemblies:
return(GetPlayerAssemblies(editorCompilation, options, null));
default:
throw new ArgumentOutOfRangeException("assembliesType");
}
}
internal static string[] GetDefinesFromAssemblyName(EditorCompilation editorCompilation, string assemblyName)
{
try
{
var assembly = editorCompilation.GetCustomTargetAssemblyFromName(assemblyName);
var scriptAssemblySettings = new ScriptAssemblySettings()
{
BuildTarget = EditorUserBuildSettings.activeBuildTarget,
BuildTargetGroup = EditorUserBuildSettings.activeBuildTargetGroup,
CompilationOptions = EditorScriptCompilationOptions.BuildingForEditor
};
return(editorCompilation.GetTargetAssemblyDefines(assembly, scriptAssemblySettings));
}
catch (ArgumentException)
{
return(null);
}
}
internal static string[] GetPrecompiledAssemblyPaths(EditorCompilation editorCompilation, PrecompiledAssemblySources precompiledAssemblySources)
{
HashSet <string> assemblyNames = new HashSet <string>();
sc.AssemblyFlags flags = sc.AssemblyFlags.None;
if ((precompiledAssemblySources & PrecompiledAssemblySources.SystemAssembly) != 0)
{
var apiCompat = (EditorApplication.scriptingRuntimeVersion == ScriptingRuntimeVersion.Latest) ? ApiCompatibilityLevel.NET_4_6 : ApiCompatibilityLevel.NET_2_0;
foreach (var a in MonoLibraryHelpers.GetSystemLibraryReferences(apiCompat, Scripting.ScriptCompilers.CSharpSupportedLanguage))
{
assemblyNames.Add(a);
}
}
if ((precompiledAssemblySources & PrecompiledAssemblySources.UnityEngine) != 0)
{
flags |= sc.AssemblyFlags.UnityModule;
}
if ((precompiledAssemblySources & PrecompiledAssemblySources.UnityEditor) != 0)
{
flags |= sc.AssemblyFlags.EditorOnly;
}
if ((precompiledAssemblySources & PrecompiledAssemblySources.UserAssembly) != 0)
{
flags |= sc.AssemblyFlags.UserAssembly;
}
var precompiledAssemblies = editorCompilation.GetAllPrecompiledAssemblies().Concat(EditorCompilationInterface.Instance.GetUnityAssemblies());
foreach (var a in precompiledAssemblies.Where(x => (x.Flags & flags) != 0))
{
assemblyNames.Add(a.Path);
}
return(assemblyNames.ToArray());
}
private string[] GetDefaultDefines(EditorCompilation editorCompilation)
{
return(editorCompilation.GetAssemblyBuilderDefaultDefines(this));
}
internal static void RequestScriptCompilation(EditorCompilation editorCompilation)
{
editorCompilation.DirtyAllScripts();
}
private static Assembly[] GetEditorAssemblies(EditorCompilation editorCompilation, EditorScriptCompilationOptions additionalOptions, string[] defines)
{
var scriptAssemblies = editorCompilation.GetAllScriptAssemblies(EditorScriptCompilationOptions.BuildingForEditor | additionalOptions, defines);
return(ToAssemblies(scriptAssemblies));
}
internal static string GetPrecompiledAssemblyPathFromAssemblyName(string assemblyName, EditorCompilation editorCompilation)
{
var precompiledAssembliesWithName = editorCompilation.GetAllPrecompiledAssemblies()
.Where(x => AssetPath.GetFileName(x.Path) == assemblyName && (x.Flags & sc.AssemblyFlags.UserAssembly) == sc.AssemblyFlags.UserAssembly);
if (precompiledAssembliesWithName.Any())
{
return(precompiledAssembliesWithName.Single().Path);
}
return(null);
}
