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); }