public bool IsCompatibleWith(BuildTarget buildTarget, EditorScriptCompilationOptions options, string[] defines)
{
bool buildingForEditor = (options & EditorScriptCompilationOptions.BuildingForEditor) == EditorScriptCompilationOptions.BuildingForEditor;
var isBuildingWithTestAssemblies = (options & EditorScriptCompilationOptions.BuildingIncludingTestAssemblies) == EditorScriptCompilationOptions.BuildingIncludingTestAssemblies;
var isTestAssembly = DefineConstraints != null && DefineConstraints.Any(x => x == "UNITY_INCLUDE_TESTS");
if (!buildingForEditor && isTestAssembly && !isBuildingWithTestAssemblies)
{
return(false);
}
if (defines != null && defines.Length == 0)
{
throw new ArgumentException("Defines cannot be empty", "defines");
}
// Log invalid define constraints
if (DefineConstraints != null)
{
for (var i = 0; i < DefineConstraints.Length; ++i)
{
if (!DefineConstraintsHelper.IsDefineConstraintValid(DefineConstraints[i]))
{
throw new AssemblyDefinitionException($"Invalid Define Constraint: \"{DefineConstraints[i]}\" at line {(i+1).ToString()}", FilePath);
}
}
}
if (!DefineConstraintsHelper.IsDefineConstraintsCompatible(defines, DefineConstraints))
{
return(false);
}
if (isTestAssembly && AssetPathMetaData != null && !AssetPathMetaData.IsTestable)
{
return(false);
}
// Compatible with editor and all platforms.
if (IncludePlatforms == null && ExcludePlatforms == null)
{
return(true);
}
if (buildingForEditor)
{
return(IsCompatibleWithEditor());
}
if (ExcludePlatforms != null)
{
return(ExcludePlatforms.All(p => p.BuildTarget != buildTarget));
}
return(IncludePlatforms.Any(p => p.BuildTarget == buildTarget));
}
public CompilationTask(ScriptAssembly[] scriptAssemblies, string buildOutputDirectory, EditorScriptCompilationOptions options, CompilationTaskOptions compilationTaskOptions, int maxConcurrentCompilers)
{
pendingAssemblies = new HashSet <ScriptAssembly>(scriptAssemblies);
CompileErrors = false;
this.buildOutputDirectory = buildOutputDirectory;
this.options = options;
this.compilationTaskOptions = compilationTaskOptions;
this.maxConcurrentCompilers = maxConcurrentCompilers;
}
public MonoIsland ToMonoIsland(EditorScriptCompilationOptions options, string buildOutputDirectory)
{
bool editor = (options & EditorScriptCompilationOptions.BuildingForEditor) == EditorScriptCompilationOptions.BuildingForEditor;
bool development_player = (options & EditorScriptCompilationOptions.BuildingDevelopmentBuild) == EditorScriptCompilationOptions.BuildingDevelopmentBuild;
IEnumerable <string> first = from a in this.ScriptAssemblyReferences
select AssetPath.Combine(a.OutputDirectory, a.Filename);
string[] references = first.Concat(this.References).ToArray <string>();
string output = AssetPath.Combine(buildOutputDirectory, this.Filename);
return(new MonoIsland(this.BuildTarget, editor, development_player, this.ApiCompatibilityLevel, this.Files, references, this.Defines, output));
}
public static EditorCompilation.CompileStatus TickCompilationPipeline(EditorScriptCompilationOptions options, BuildTargetGroup platformGroup, BuildTarget platform, int subtarget, string[] extraScriptingDefines = null)
{
try
{
return(Instance.TickCompilationPipeline(options, platformGroup, platform, subtarget, extraScriptingDefines));
}
catch (Exception e)
{
LogException(e);
return(EditorCompilation.CompileStatus.CompilationFailed);
}
}
public MonoIsland[] GetAllMonoIslands(PrecompiledAssembly[] unityAssembliesArg, PrecompiledAssembly[] precompiledAssembliesArg, BuildFlags buildFlags)
{
EditorScriptCompilationOptions options = ((buildFlags & BuildFlags.BuildingForEditor) == BuildFlags.None) ? EditorScriptCompilationOptions.BuildingEmpty : EditorScriptCompilationOptions.BuildingForEditor;
ScriptAssembly[] allScriptAssemblies = this.GetAllScriptAssemblies(buildFlags, options, unityAssembliesArg, precompiledAssembliesArg);
MonoIsland[] array = new MonoIsland[allScriptAssemblies.Length];
for (int i = 0; i < allScriptAssemblies.Length; i++)
{
array[i] = allScriptAssemblies[i].ToMonoIsland(BuildFlags.BuildingForEditor, EditorCompilation.EditorTempPath);
}
return(array);
}
private ScriptAssembly[] GetAllScriptAssemblies(BuildFlags buildFlags, EditorScriptCompilationOptions options, PrecompiledAssembly[] unityAssembliesArg, PrecompiledAssembly[] precompiledAssembliesArg)
{
EditorBuildRules.CompilationAssemblies assemblies = new EditorBuildRules.CompilationAssemblies
{
UnityAssemblies = unityAssembliesArg,
PrecompiledAssemblies = precompiledAssembliesArg,
CustomTargetAssemblies = this.customTargetAssemblies,
EditorAssemblyReferences = ModuleUtils.GetAdditionalReferencesForUserScripts()
};
ScriptAssemblySettings settings = this.CreateEditorScriptAssemblySettings(options);
return(EditorBuildRules.GetAllScriptAssemblies(this.allScripts, this.projectDirectory, buildFlags, settings, assemblies));
}
public CompilationTask(ScriptAssembly[] scriptAssemblies,
ScriptAssembly[] codeGenAssemblies,
string buildOutputDirectory,
object context,
EditorScriptCompilationOptions options,
CompilationTaskOptions compilationTaskOptions,
int maxConcurrentCompilers,
IILPostProcessing ilPostProcessing,
CompilerFactory compilerFactory)
{
this.scriptAssemblies = scriptAssemblies;
pendingAssemblies = new List <ScriptAssembly>();
if (codeGenAssemblies != null)
{
this.codeGenAssemblies = new HashSet <ScriptAssembly>(codeGenAssemblies);
}
else
{
this.codeGenAssemblies = new HashSet <ScriptAssembly>();
}
// Try to queue codegen assemblies for compilation first,
// so they get compiled as soon as possible.
if (codeGenAssemblies != null && codeGenAssemblies.Count() > 0)
{
pendingAssemblies.AddRange(codeGenAssemblies);
}
pendingAssemblies.AddRange(scriptAssemblies);
CompileErrors = false;
this.buildOutputDirectory = buildOutputDirectory;
this.context = context;
this.options = options;
this.compilationTaskOptions = compilationTaskOptions;
this.maxConcurrentCompilers = maxConcurrentCompilers;
this.ilPostProcessing = ilPostProcessing;
this.compilerFactory = compilerFactory;
try
{
logWriter = File.CreateText(LogFilePath);
}
catch (Exception e)
{
Console.WriteLine($"Could not create text file {LogFilePath}\n{e}");
}
}
public CompilationTask(ScriptAssembly[] scriptAssemblies,
string buildOutputDirectory,
object context,
EditorScriptCompilationOptions options,
CompilationTaskOptions compilationTaskOptions,
int maxConcurrentCompilers,
Func <ScriptAssembly, List <CompilerMessage>, string, List <CompilerMessage> > postProcessFunc)
{
pendingAssemblies = new HashSet <ScriptAssembly>(scriptAssemblies);
CompileErrors = false;
this.buildOutputDirectory = buildOutputDirectory;
this.context = context;
this.options = options;
this.compilationTaskOptions = compilationTaskOptions;
this.maxConcurrentCompilers = maxConcurrentCompilers;
this.postProcessFunc = postProcessFunc;
}
public CompilationTask(ScriptAssembly[] scriptAssemblies,
string buildOutputDirectory,
object context,
EditorScriptCompilationOptions options,
CompilationTaskOptions compilationTaskOptions,
int maxConcurrentCompilers,
IILPostProcessing ilPostProcessing)
{
pendingAssemblies = new HashSet <ScriptAssembly>(scriptAssemblies);
CompileErrors = false;
this.buildOutputDirectory = buildOutputDirectory;
this.context = context;
this.options = options;
this.compilationTaskOptions = compilationTaskOptions;
this.maxConcurrentCompilers = maxConcurrentCompilers;
this.ilPostProcessing = ilPostProcessing;
}
public bool IsCompatibleWith(BuildTarget buildTarget, EditorScriptCompilationOptions options, string[] defines)
{
bool buildingForEditor = (options & EditorScriptCompilationOptions.BuildingForEditor) == EditorScriptCompilationOptions.BuildingForEditor;
var isTestAssembly = (OptionalUnityReferences & OptionalUnityReferences.TestAssemblies) == OptionalUnityReferences.TestAssemblies;
var isBuildingWithTestAssemblies = (options & EditorScriptCompilationOptions.BuildingIncludingTestAssemblies) == EditorScriptCompilationOptions.BuildingIncludingTestAssemblies;
if (!buildingForEditor && isTestAssembly && !isBuildingWithTestAssemblies)
{
return(false);
}
if (defines != null && defines.Length == 0)
{
throw new ArgumentException("defines cannot be empty", "defines");
}
if (!DefineConstraintsHelper.IsDefineConstraintsCompatible(defines, DefineConstraints))
{
return(false);
}
if (isTestAssembly && AssetPathMetaData != null && !AssetPathMetaData.IsTestable)
{
return(false);
}
// Compatible with editor and all platforms.
if (IncludePlatforms == null && ExcludePlatforms == null)
{
return(true);
}
if (buildingForEditor)
{
return(IsCompatibleWithEditor());
}
if (ExcludePlatforms != null)
{
return(ExcludePlatforms.All(p => p.BuildTarget != buildTarget));
}
return(IncludePlatforms.Any(p => p.BuildTarget == buildTarget));
}
public bool IsCompatibleWith(BuildTarget buildTarget, EditorScriptCompilationOptions options)
{
bool flag = (options & EditorScriptCompilationOptions.BuildingForEditor) == EditorScriptCompilationOptions.BuildingForEditor;
bool flag2 = (this.OptionalUnityReferences & OptionalUnityReferences.TestAssemblies) == OptionalUnityReferences.TestAssemblies;
bool flag3 = (options & EditorScriptCompilationOptions.BuildingIncludingTestAssemblies) == EditorScriptCompilationOptions.BuildingIncludingTestAssemblies;
bool result;
if (!flag && flag2 && !flag3)
{
result = false;
}
else
{
bool hasValue = this.PackageAssembly.HasValue;
if (flag2 && hasValue && !this.PackageAssembly.Value.IncludeTestAssemblies)
{
result = false;
}
else if (this.IncludePlatforms == null && this.ExcludePlatforms == null)
{
result = true;
}
else if (flag)
{
result = this.IsCompatibleWithEditor();
}
else
{
if (flag)
{
buildTarget = BuildTarget.NoTarget;
}
if (this.ExcludePlatforms != null)
{
result = this.ExcludePlatforms.All((CustomScriptAssemblyPlatform p) => p.BuildTarget != buildTarget);
}
else
{
result = this.IncludePlatforms.Any((CustomScriptAssemblyPlatform p) => p.BuildTarget == buildTarget);
}
}
}
return(result);
}
public bool IsCompatibleWith(BuildTarget buildTarget, EditorScriptCompilationOptions options, string[] defines = null)
{
bool buildingForEditor = (options & EditorScriptCompilationOptions.BuildingForEditor) == EditorScriptCompilationOptions.BuildingForEditor;
var isTestAssembly = (OptionalUnityReferences & OptionalUnityReferences.TestAssemblies) == OptionalUnityReferences.TestAssemblies;
var isBuildingWithTestAssemblies = (options & EditorScriptCompilationOptions.BuildingIncludingTestAssemblies) == EditorScriptCompilationOptions.BuildingIncludingTestAssemblies;
if (!buildingForEditor && isTestAssembly && !isBuildingWithTestAssemblies)
{
return(false);
}
if (!DefineConstraintsHelper.IsDefineConstraintsCompatible(defines, DefineConstraints))
{
return(false);
}
var isPackage = PackageAssembly.HasValue;
if (isTestAssembly && isPackage && !PackageAssembly.Value.IncludeTestAssemblies)
{
return(false);
}
// Compatible with editor and all platforms.
if (IncludePlatforms == null && ExcludePlatforms == null)
{
return(true);
}
if (buildingForEditor)
{
return(IsCompatibleWithEditor());
}
if (ExcludePlatforms != null)
{
return(ExcludePlatforms.All(p => p.BuildTarget != buildTarget));
}
return(IncludePlatforms.Any(p => p.BuildTarget == buildTarget));
}
public MonoIsland ToMonoIsland(EditorScriptCompilationOptions options, string buildOutputDirectory)
{
bool buildingForEditor = (options & EditorScriptCompilationOptions.BuildingForEditor) == EditorScriptCompilationOptions.BuildingForEditor;
bool developmentBuild = (options & EditorScriptCompilationOptions.BuildingDevelopmentBuild) == EditorScriptCompilationOptions.BuildingDevelopmentBuild;
var references = ScriptAssemblyReferences.Select(a => AssetPath.Combine(a.OutputDirectory, a.Filename));
var referencesArray = references.Concat(References).ToArray();
var outputPath = AssetPath.Combine(buildOutputDirectory, Filename);
return(new MonoIsland(BuildTarget,
buildingForEditor,
developmentBuild,
CompilerOptions.AllowUnsafeCode,
ApiCompatibilityLevel,
Files,
referencesArray,
Defines,
outputPath));
}
public bool IsCompatibleWith(BuildTarget buildTarget, EditorScriptCompilationOptions options, string[] defines)
{
bool buildingForEditor = (options & EditorScriptCompilationOptions.BuildingForEditor) == EditorScriptCompilationOptions.BuildingForEditor;
var isBuildingWithTestAssemblies = (options & EditorScriptCompilationOptions.BuildingIncludingTestAssemblies) == EditorScriptCompilationOptions.BuildingIncludingTestAssemblies;
var isTestAssembly = DefineConstraints != null && DefineConstraints.Any(x => x == "UNITY_INCLUDE_TESTS");
if (!buildingForEditor && isTestAssembly && !isBuildingWithTestAssemblies)
{
return false;
}
if (defines != null && defines.Length == 0)
throw new ArgumentException("defines cannot be empty", "defines");
if (!DefineConstraintsHelper.IsDefineConstraintsCompatible(defines, DefineConstraints))
{
return false;
}
if (isTestAssembly && AssetPathMetaData != null && !AssetPathMetaData.IsTestable)
{
return false;
}
// Compatible with editor and all platforms.
if (IncludePlatforms == null && ExcludePlatforms == null)
return true;
if (buildingForEditor)
return IsCompatibleWithEditor();
if (ExcludePlatforms != null)
return ExcludePlatforms.All(p => p.BuildTarget != buildTarget);
return IncludePlatforms.Any(p => p.BuildTarget == buildTarget);
}
public static List <string> GetPrecompiledReferences(ScriptAssembly scriptAssembly, TargetAssemblyType targetAssemblyType, EditorScriptCompilationOptions options, EditorCompatibility editorCompatibility, IEnumerable <PrecompiledAssembly> implicitPrecompiledAssemblies, IEnumerable <PrecompiledAssembly> explicitPrecompiledAssemblies, ICompilationSetupWarningTracker warningSink)
{
var references = new List <string>();
bool buildingForEditor = (options & EditorScriptCompilationOptions.BuildingForEditor) == EditorScriptCompilationOptions.BuildingForEditor;
bool assemblyEditorOnly = (scriptAssembly.Flags & AssemblyFlags.EditorOnly) == AssemblyFlags.EditorOnly;
bool isCustomAssembly = (targetAssemblyType & TargetAssemblyType.Custom) == TargetAssemblyType.Custom;
void AddReferenceIfMatchBuildTargetAndEditorFlag(PrecompiledAssembly precompiledAssembly, bool explicitReference)
{
bool compiledAssemblyEditorOnly = (precompiledAssembly.Flags & AssemblyFlags.EditorOnly) == AssemblyFlags.EditorOnly;
// Add all pre-compiled runtime assemblies as references to all script assemblies. Don't add pre-compiled editor assemblies as dependencies to runtime assemblies.
if (!compiledAssemblyEditorOnly || assemblyEditorOnly || (isCustomAssembly && buildingForEditor && editorCompatibility == EditorCompatibility.CompatibleWithEditor))
{
if (IsPrecompiledAssemblyCompatibleWithBuildTarget(precompiledAssembly, scriptAssembly.BuildTarget))
{
references.Add(precompiledAssembly.Path);
}
// we don't warn on build target mismatch, as this is actually a common pattern (an asmdef with multiple references to different "target-specific" assemblies with the same symbols - e.g. foo.XboxOne.dll, foo.PS5.dll, foo.WebGL.dll)
}
else if (explicitReference && !string.IsNullOrEmpty(scriptAssembly.AsmDefPath))
{
warningSink?.AddAssetWarning(scriptAssembly.AsmDefPath, $"{scriptAssembly.Filename}: can't add reference to {precompiledAssembly.Path} as it is an editor-only assembly");
}
}
if (implicitPrecompiledAssemblies != null)
{
foreach (var precompiledAssembly in implicitPrecompiledAssemblies)
{
AddReferenceIfMatchBuildTargetAndEditorFlag(precompiledAssembly, false);
}
}
if (explicitPrecompiledAssemblies != null)
{
foreach (var precompiledAssembly in explicitPrecompiledAssemblies)
{
AddReferenceIfMatchBuildTargetAndEditorFlag(precompiledAssembly, true);
}
}
return(references);
}
public static EditorCompilation.TargetAssemblyInfo[] GetCompatibleTargetAssemblyInfos(EditorScriptCompilationOptions definesOptions, BuildTargetGroup platformGroup, BuildTarget platform, string[] extraScriptingDefines = null)
{
var scriptAssemblySettings = Instance.CreateScriptAssemblySettings(platformGroup, platform, definesOptions, extraScriptingDefines);
return(Instance.GetTargetAssemblyInfos(scriptAssemblySettings));
}
public static EditorCompilation.CompileStatus CompileScripts(EditorScriptCompilationOptions definesOptions, BuildTargetGroup platformGroup, BuildTarget platform, int subtarget, string[] extraScriptingDefines = null)
{
return(EmitExceptionAsError(() => Instance.CompileScripts(definesOptions, platformGroup, platform, subtarget, extraScriptingDefines),
EditorCompilation.CompileStatus.CompilationFailed));
}
public static Dictionary <string, string> GetUnityReferences(ScriptAssembly scriptAssembly, TargetAssembly targetAssembly, PrecompiledAssembly[] unityAssemblies, HashSet <string> predefinedCustomTargetReferences, EditorScriptCompilationOptions options, UnityReferencesOptions unityReferencesOptions)
{
var references = new Dictionary <string, string>();
bool assemblyEditorOnly = (scriptAssembly.Flags & AssemblyFlags.EditorOnly) == AssemblyFlags.EditorOnly;
bool buildingForEditor = (options & EditorScriptCompilationOptions.BuildingForEditor) == EditorScriptCompilationOptions.BuildingForEditor;
bool excludeUnityModules = unityReferencesOptions == UnityReferencesOptions.ExcludeModules;
bool isOverridingUnityAssembly = false;
// Add Unity assemblies (UnityEngine.dll, UnityEditor.dll) referencees.
if (unityAssemblies == null)
{
return(references);
}
foreach (var unityAssembly in unityAssemblies)
{
if ((unityAssembly.Flags & (AssemblyFlags.UserOverride | AssemblyFlags.UserOverrideCandidate)) != AssemblyFlags.None)
{
var unityAssemblyFileName = AssetPath.GetFileName(unityAssembly.Path);
// This scriptAssembly is overriding this unityAssembly so it should probably not depend on itself.
if (unityAssemblyFileName == scriptAssembly.Filename)
{
isOverridingUnityAssembly = true;
continue;
}
// Custom targets may override Unity references, do not add them to avoid duplicated references.
if (predefinedCustomTargetReferences != null && predefinedCustomTargetReferences.Contains(unityAssemblyFileName))
{
continue;
}
// If this scriptAssembly/targetAssembly explicitly references another
// scriptAssembly that has actually overridden this unityAssembly, we should
// not add the unityAssembly to the references as well. It's possible
// that this scriptAssembly is using new APIs that don't exist in the shipped
// copy of the unityAssembly.
if (targetAssembly != null && targetAssembly.References.Any(ta => ta.Filename == unityAssemblyFileName))
{
continue;
}
}
var isUnityModule = (unityAssembly.Flags & AssemblyFlags.UnityModule) == AssemblyFlags.UnityModule;
if (isUnityModule && excludeUnityModules)
{
continue;
}
var moduleExcludedForRuntimeCode = (unityAssembly.Flags & AssemblyFlags.ExcludedForRuntimeCode) == AssemblyFlags.ExcludedForRuntimeCode;
// Add Unity editor assemblies (UnityEditor.dll) to all assemblies when building inside the editor
if ((buildingForEditor && !moduleExcludedForRuntimeCode) || assemblyEditorOnly)
{
if ((unityAssembly.Flags & AssemblyFlags.UseForMono) != 0)
{
references[Path.GetFileName(unityAssembly.Path)] = unityAssembly.Path;
}
}
else
{
bool unityAssemblyEditorOnly = (unityAssembly.Flags & AssemblyFlags.EditorOnly) == AssemblyFlags.EditorOnly;
// Add Unity runtime assemblies (UnityEngine.dll) to all assemblies
if (!unityAssemblyEditorOnly && !moduleExcludedForRuntimeCode)
{
if (IsPrecompiledAssemblyCompatibleWithBuildTarget(unityAssembly, scriptAssembly.BuildTarget))
{
references[Path.GetFileName(unityAssembly.Path)] = unityAssembly.Path;
}
}
}
}
// UserOverride assemblies should not have a dependency on Editor assemblies.
if (isOverridingUnityAssembly && !assemblyEditorOnly)
{
references = references.Where(kvp => !kvp.Key.Contains("UnityEditor")).ToDictionary(kvp => kvp.Key, kvp => kvp.Value);
}
return(references);
}
private static Assembly[] GetEditorAssemblies(EditorCompilation editorCompilation, EditorScriptCompilationOptions additionalOptions, string[] defines)
{
var scriptAssemblies = editorCompilation.GetAllScriptAssemblies(EditorScriptCompilationOptions.BuildingForEditor | additionalOptions, defines);
return(ToAssemblies(scriptAssemblies));
}
protected ScriptCompilerBase(ScriptAssembly assembly, EditorScriptCompilationOptions options, string tempOutputDirectory)
{
this.assembly = assembly;
this.options = options;
this.tempOutputDirectory = tempOutputDirectory;
}
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));
}
public static bool IsCompatibleWithPlatformAndDefines(TargetAssembly assembly, BuildTarget buildTarget, EditorScriptCompilationOptions options)
{
var settings = new ScriptAssemblySettings
{
BuildTarget = buildTarget,
CompilationOptions = options
};
return(IsCompatibleWithPlatformAndDefines(assembly, settings));
}
extern internal static string[] GetCompilationDefines(EditorScriptCompilationOptions options, BuildTargetGroup targetGroup, BuildTarget target, ApiCompatibilityLevel apiCompatibilityLevel);
public static bool CompileCustomScriptAssemblies(EditorScriptCompilationOptions definesOptions, BuildTargetGroup platformGroup, BuildTarget platform)
{
return(EmitExceptionAsError(() => Instance.CompileCustomScriptAssemblies(definesOptions, platformGroup, platform), false));
}
public static void DirtyPredefinedAssemblyScripts(EditorScriptCompilationOptions options, BuildTargetGroup platformGroup, BuildTarget platform)
{
EmitExceptionAsError(() => Instance.DirtyPredefinedAssemblyScripts(options, platformGroup, platform));
}
public abstract ScriptCompilerBase CreateCompiler(ScriptAssembly scriptAssembly, EditorScriptCompilationOptions options, string tempOutputDirectory);
public static EditorCompilation.CompileStatus TickCompilationPipeline(EditorScriptCompilationOptions options, BuildTargetGroup platformGroup, BuildTarget platform)
{
return(EmitExceptionAsError(() => Instance.TickCompilationPipeline(options, platformGroup, platform), EditorCompilation.CompileStatus.Idle));
}
public override ScriptCompilerBase CreateCompiler(ScriptAssembly scriptAssembly, EditorScriptCompilationOptions options, string tempOutputDirectory)
{
return(new MicrosoftCSharpCompiler(scriptAssembly, options, tempOutputDirectory));
}
internal static string[] GetCompilationDefines(EditorScriptCompilationOptions options, BuildTargetGroup targetGroup, BuildTarget target)
{
return(GetCompilationDefines(options, targetGroup, target, PlayerSettings.GetApiCompatibilityLevel(targetGroup)));
}
public static EditorCompilation.TargetAssemblyInfo[] GetAllCompiledAndResolvedTargetAssemblies(EditorScriptCompilationOptions options, BuildTarget buildTarget)
{
EditorCompilation.CustomScriptAssemblyAndReference[] assembliesWithMissingReference = null;
var result = EmitExceptionAsError(() => Instance.GetAllCompiledAndResolvedTargetAssemblies(options, buildTarget, out assembliesWithMissingReference), new EditorCompilation.TargetAssemblyInfo[0]);
if (assembliesWithMissingReference != null && assembliesWithMissingReference.Length > 0)
{
foreach (var assemblyAndReference in assembliesWithMissingReference)
{
LogWarning(string.Format("The assembly for Assembly Definition File '{0}' will not be loaded. Because the assembly for its reference '{1}'' does not exist on the file system. " +
"This can be caused by the reference assembly not being compiled due to errors or not having any scripts associated with it.",
assemblyAndReference.Assembly.FilePath,
assemblyAndReference.Reference.FilePath),
assemblyAndReference.Assembly.FilePath);
}
}
// Check we do not have any assembly definition references (asmref) without matching assembly definitions (asmdef)
List <CustomScriptAssemblyReference> referencesWithMissingAssemblies;
Instance.GetAssemblyDefinitionReferencesWithMissingAssemblies(out referencesWithMissingAssemblies);
if (referencesWithMissingAssemblies.Count > 0)
{
foreach (var asmref in referencesWithMissingAssemblies)
{
var warning = $"The Assembly Definition Reference file '{asmref.FilePath}' will not be used. ";
if (string.IsNullOrEmpty(asmref.Reference))
{
warning += "It does not contain a reference to an Assembly Definition File.";
}
else
{
warning += $"The reference to the Assembly Definition File with the name '{asmref.Reference}' could not be found.";
}
LogWarning(warning, asmref.FilePath);
}
}
return(result);
}
