public void LogVersionDefineError(TargetAssembly targetAssembly, ExpressionNotValidException validationError)
{
var asset = AssetDatabase.LoadAssetAtPath <AssemblyDefinitionAsset>(EditorCompilationInterface.Instance.FindCustomTargetAssemblyFromTargetAssembly(targetAssembly).FilePath);
var instanceID = asset.GetInstanceID();
InternalLogVersionDefineError(validationError, instanceID);
}
internal static TargetAssembly GetPredefinedTargetAssembly(string scriptPath)
{
TargetAssembly resultAssembly = null;
var lowerPath = ScriptPathToLowerCase(scriptPath);
int highestPathDepth = -1;
foreach (var assembly in predefinedTargetAssemblies)
{
var pathFilter = assembly.PathFilter;
int pathDepth = -1;
if (pathFilter == null)
{
pathDepth = 0;
}
else
{
pathDepth = pathFilter(lowerPath);
}
if (pathDepth > highestPathDepth)
{
resultAssembly = assembly;
highestPathDepth = pathDepth;
}
}
return(resultAssembly);
}
internal static TargetAssembly GetPredefinedTargetAssembly(string scriptPath, string assemblyName = null)
{
if (assemblyName == null)
{
TargetAssembly resultAssembly = null;
var lowerPath = ScriptPathToLowerCase(scriptPath);
int highestPathDepth = -1;
foreach (var assembly in predefinedTargetAssemblies.Values)
{
var pathDepth = assembly.PathFilter?.Invoke(lowerPath) ?? 0;
if (pathDepth <= highestPathDepth)
{
continue;
}
resultAssembly = assembly;
highestPathDepth = pathDepth;
}
return(resultAssembly);
}
if (predefinedTargetAssemblies.TryGetValue(assemblyName, out var predefined))
{
return(predefined);
}
return(null);
}
public static bool ShouldAddTestRunnerReferences(TargetAssembly targetAssembly)
{
if (UnityCodeGenHelpers.IsCodeGen(targetAssembly.Filename))
{
return(false);
}
bool referencesTestRunnerAssembly = false;
foreach (var reference in targetAssembly.References)
{
referencesTestRunnerAssembly =
reference.Filename.Equals(k_EditorTestRunnerAssemblyName, StringComparison.Ordinal) ||
reference.Filename.Equals(k_EngineTestRunnerAssemblyName, StringComparison.Ordinal);
if (referencesTestRunnerAssembly)
{
break;
}
}
return(!referencesTestRunnerAssembly &&
!targetAssembly.Filename.Equals(k_EditorTestRunnerAssemblyName, StringComparison.Ordinal) &&
!targetAssembly.Filename.Equals(k_EngineTestRunnerAssemblyName, StringComparison.Ordinal) &&
(PlayerSettings.playModeTestRunnerEnabled || (targetAssembly.Flags & AssemblyFlags.EditorOnly) == AssemblyFlags.EditorOnly));
}
internal static void AddTestRunnerCustomReferences(ref TargetAssembly targetAssembly, Dictionary <string, TargetAssembly> assembliesCustomTargetAssemblies)
{
if (TestRunnerHelpers.ShouldAddTestRunnerReferences(targetAssembly) && assembliesCustomTargetAssemblies != null)
{
targetAssembly.References.AddRange(TestRunnerHelpers.GetReferences(assembliesCustomTargetAssemblies.Values));
}
}
internal static void AddTestRunnerPrecompiledReferences(TargetAssembly targetAssembly, Dictionary <string, PrecompiledAssembly> nameToPrecompiledAssemblies, ref List <PrecompiledAssembly> precompiledReferences)
{
if (TestRunnerHelpers.ShouldAddNunitReferences(targetAssembly))
{
TestRunnerHelpers.AddNunitReferences(nameToPrecompiledAssemblies, ref precompiledReferences);
}
}
internal static TargetAssembly GetCustomTargetAssembly(string scriptPath, string projectDirectory, TargetAssembly[] customTargetAssemblies)
{
if (customTargetAssemblies == null)
{
return(null);
}
int highestPathDepth = -1;
TargetAssembly resultAssembly = null;
// CustomScriptAssembly paths are absolute, so we convert the scriptPath to an absolute path, if necessary.
bool isPathAbsolute = AssetPath.IsPathRooted(scriptPath);
var lowerFullPath = isPathAbsolute ? AssetPath.GetFullPath(scriptPath).ToLower() : AssetPath.Combine(projectDirectory, scriptPath).ToLower();
foreach (var assembly in customTargetAssemblies)
{
int pathDepth = assembly.PathFilter(lowerFullPath);
if (pathDepth <= highestPathDepth)
{
continue;
}
resultAssembly = assembly;
highestPathDepth = pathDepth;
}
return(resultAssembly);
}
public static bool IsCompatibleWithPlatformAndDefines(TargetAssembly assembly, BuildTarget buildTarget, EditorScriptCompilationOptions options)
{
var settings = new ScriptAssemblySettings
{
BuildTarget = buildTarget,
CompilationOptions = options
};
return(IsCompatibleWithPlatformAndDefines(assembly, settings));
}
internal static TargetAssembly GetTargetAssembly(string scriptPath, string projectDirectory, TargetAssembly[] customTargetAssemblies)
{
TargetAssembly resultAssembly = GetCustomTargetAssembly(scriptPath, projectDirectory, customTargetAssemblies);
if (resultAssembly != null)
{
return(resultAssembly);
}
return(GetPredefinedTargetAssembly(scriptPath));
}
internal static TargetAssembly GetTargetAssemblyLinearSearch(string scriptPath, string projectDirectory, IDictionary <string, TargetAssembly> customTargetAssemblies)
{
TargetAssembly resultAssembly = GetCustomTargetAssembly(scriptPath, projectDirectory, customTargetAssemblies);
if (resultAssembly != null)
{
return(resultAssembly);
}
// Do not compile scripts outside the Assets/ folder into predefined assemblies.
if (!Utility.IsAssetsPath(scriptPath))
{
return(null);
}
return(GetPredefinedTargetAssembly(scriptPath));
}
public static bool ShouldAddNunitReferences(TargetAssembly targetAssembly)
{
bool referencesNUnit = false;
if ((targetAssembly.Flags & AssemblyFlags.ExplicitReferences) == AssemblyFlags.ExplicitReferences)
{
foreach (var explicitPrecompiledReference in targetAssembly.ExplicitPrecompiledReferences)
{
referencesNUnit = explicitPrecompiledReference.Equals(NunitAssemblyName, StringComparison.Ordinal);
if (referencesNUnit)
{
break;
}
}
}
return(!referencesNUnit &&
(PlayerSettings.playModeTestRunnerEnabled || (targetAssembly.Flags & AssemblyFlags.EditorOnly) == AssemblyFlags.EditorOnly));
}
static bool ShouldUseAnalyzerForScriptAssembly(ScriptAssembly sa, TargetAssembly targetAssemblyOwningAnalyzer)
{
if (targetAssemblyOwningAnalyzer == null)
{
return(true);
}
if (sa.Filename == targetAssemblyOwningAnalyzer.Filename)
{
return(true);
}
foreach (var sar in sa.ScriptAssemblyReferences)
{
if (ShouldUseAnalyzerForScriptAssembly(sar, targetAssemblyOwningAnalyzer))
{
return(true);
}
}
return(false);
}
internal static TargetAssembly GetPredefinedTargetAssembly(string scriptPath)
{
TargetAssembly resultAssembly = null;
var extension = AssetPath.GetExtension(scriptPath).Substring(1).ToLower();
var lowerPath = ("/" + scriptPath.ToLower()).ConvertSeparatorsToUnity();
int highestPathDepth = -1;
foreach (var assembly in predefinedTargetAssemblies)
{
if (extension != assembly.Language.GetExtensionICanCompile())
{
continue;
}
var pathFilter = assembly.PathFilter;
int pathDepth = -1;
if (pathFilter == null)
{
pathDepth = 0;
}
else
{
pathDepth = pathFilter(lowerPath);
}
if (pathDepth > highestPathDepth)
{
resultAssembly = assembly;
highestPathDepth = pathDepth;
}
}
return(resultAssembly);
}
internal static TargetAssembly[] CreatePredefinedTargetAssemblies()
{
var runtimeFirstPassAssemblies = new List <TargetAssembly>();
var runtimeAssemblies = new List <TargetAssembly>();
var editorFirstPassAssemblies = new List <TargetAssembly>();
var editorAssemblies = new List <TargetAssembly>();
var assemblies = new List <TargetAssembly>();
var scriptCompilerOptions = new ScriptCompilerOptions();
// Initialize predefined assembly targets
{
const string languageName = "CSharp";
var runtimeFirstPass = new TargetAssembly("Assembly-" + languageName + "-firstpass" + ".dll",
AssemblyFlags.FirstPass | AssemblyFlags.UserAssembly,
TargetAssemblyType.Predefined,
null,
null,
FilterAssemblyInFirstpassFolder,
null,
scriptCompilerOptions);
var runtime = new TargetAssembly("Assembly-" + languageName + ".dll",
AssemblyFlags.UserAssembly,
TargetAssemblyType.Predefined,
null,
null,
null,
null,
scriptCompilerOptions);
var editorFirstPass = new TargetAssembly("Assembly-" + languageName + "-Editor-firstpass" + ".dll",
AssemblyFlags.EditorOnly | AssemblyFlags.FirstPass | AssemblyFlags.UserAssembly,
TargetAssemblyType.Predefined,
null,
null,
FilterAssemblyInFirstpassEditorFolder,
(settings, defines) => IsCompatibleWithEditor(settings),
scriptCompilerOptions);
var editor = new TargetAssembly("Assembly-" + languageName + "-Editor" + ".dll",
AssemblyFlags.EditorOnly | AssemblyFlags.UserAssembly,
TargetAssemblyType.Predefined,
null,
null,
FilterAssemblyInEditorFolder,
(settings, defines) => IsCompatibleWithEditor(settings),
scriptCompilerOptions);
runtimeFirstPassAssemblies.Add(runtimeFirstPass);
runtimeAssemblies.Add(runtime);
editorFirstPassAssemblies.Add(editorFirstPass);
editorAssemblies.Add(editor);
assemblies.Add(runtimeFirstPass);
assemblies.Add(runtime);
assemblies.Add(editorFirstPass);
assemblies.Add(editor);
}
// Setup dependencies
// Runtime assemblies depend all first pass runtime assemblies
foreach (var assembly in runtimeAssemblies)
{
assembly.References.AddRange(runtimeFirstPassAssemblies);
}
// First pass editor assemblies depend on all first pass runtime assemblies
foreach (var assembly in editorFirstPassAssemblies)
{
assembly.References.AddRange(runtimeFirstPassAssemblies);
}
// Editor assemblies depend on all previous runtime and editor assemblies
foreach (var assembly in editorAssemblies)
{
assembly.References.AddRange(runtimeFirstPassAssemblies);
assembly.References.AddRange(runtimeAssemblies);
assembly.References.AddRange(editorFirstPassAssemblies);
}
return(assemblies.ToArray());
}
public static bool IsCompatibleWithPlatformAndDefines(TargetAssembly assembly, ScriptAssemblySettings settings)
{
return(assembly.IsCompatibleFunc == null || assembly.IsCompatibleFunc(settings, assembly.Defines));
}
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);
}
public static Dictionary <string, string> GetUnityReferences(ScriptAssembly scriptAssembly, TargetAssembly targetAssembly, PrecompiledAssembly[] unityAssemblies, EditorScriptCompilationOptions options, UnityReferencesOptions unityReferencesOptions)
{
return(GetUnityReferences(scriptAssembly, targetAssembly, unityAssemblies, null, options, unityReferencesOptions));
}
public static TargetAssembly[] CreateTargetAssemblies(IEnumerable <CustomScriptAssembly> customScriptAssemblies)
{
if (customScriptAssemblies == null)
{
return(null);
}
foreach (var customAssembly in customScriptAssemblies)
{
if (predefinedTargetAssemblies.Any(p => AssetPath.GetAssemblyNameWithoutExtension(p.Filename) == customAssembly.Name))
{
throw new Exception(string.Format("Assembly cannot be have reserved name '{0}'. Defined in '{1}'", customAssembly.Name, customAssembly.FilePath));
}
}
var targetAssemblies = new List <TargetAssembly>();
var nameToTargetAssembly = new Dictionary <string, TargetAssembly>();
// Create TargetAssemblies
foreach (var customAssembly in customScriptAssemblies)
{
var lowerPathPrefix = customAssembly.PathPrefix.ToLower(CultureInfo.InvariantCulture);
var targetAssembly = new TargetAssembly(customAssembly.Name + ".dll",
null,
customAssembly.AssemblyFlags,
TargetAssemblyType.Custom,
customAssembly.PathPrefix,
path => FastStartsWith(path, customAssembly.PathPrefix, lowerPathPrefix) ? customAssembly.PathPrefix.Length : -1,
(BuildTarget target, EditorScriptCompilationOptions options) => customAssembly.IsCompatibleWith(target, options),
customAssembly.CompilerOptions)
{
OptionalUnityReferences = customAssembly.OptionalUnityReferences,
};
targetAssemblies.Add(targetAssembly);
nameToTargetAssembly[customAssembly.Name] = targetAssembly;
}
var targetAssembliesEnumerator = targetAssemblies.GetEnumerator();
// Setup references for TargetAssemblies
foreach (var customAssembly in customScriptAssemblies)
{
targetAssembliesEnumerator.MoveNext();
var targetAssembly = targetAssembliesEnumerator.Current;
if (customAssembly.References == null)
{
continue;
}
foreach (var reference in customAssembly.References)
{
TargetAssembly referenceAssembly = null;
if (!nameToTargetAssembly.TryGetValue(reference, out referenceAssembly))
{
UnityEngine.Debug.LogWarning(string.Format("Could not find reference '{0}' for assembly '{1}'", reference, customAssembly.Name));
continue;
}
targetAssembly.References.Add(referenceAssembly);
}
}
return(targetAssemblies.ToArray());
}
internal static void AddScriptAssemblyReferences(ref ScriptAssembly scriptAssembly, TargetAssembly targetAssembly, ScriptAssemblySettings settings,
CompilationAssemblies assemblies,
IDictionary <TargetAssembly, ScriptAssembly> targetToScriptAssembly, string filenameSuffix)
{
var scriptAssemblyReferences = new List <ScriptAssembly>();
var references = new List <string>();
bool buildingForEditor = settings.BuildingForEditor;
// Add Unity assemblies (UnityEngine.dll, UnityEditor.dll) referencees.
var unityReferences = GetUnityReferences(scriptAssembly, assemblies.UnityAssemblies, settings.CompilationOptions);
references.AddRange(unityReferences);
// Setup target assembly references
foreach (var reference in targetAssembly.References)
{
ScriptAssembly scriptAssemblyReference;
// Add ScriptAssembly references to other dirty script assemblies that also need to be rebuilt.
if (targetToScriptAssembly.TryGetValue(reference, out scriptAssemblyReference))
{
System.Diagnostics.Debug.Assert(scriptAssemblyReference != null);
scriptAssemblyReferences.Add(scriptAssemblyReference);
}
else
{
// Add string references to other assemblies that do not need to be rebuilt.
var assemblyPath = reference.FullPath(settings.OutputDirectory, filenameSuffix);
if (File.Exists(assemblyPath))
{
references.Add(assemblyPath);
}
}
}
// For predefined target assembly add references to custom target assemblies
if (assemblies.CustomTargetAssemblies != null && (targetAssembly.Type & TargetAssemblyType.Predefined) == TargetAssemblyType.Predefined)
{
foreach (var customTargetAssembly in assemblies.PredefinedAssembliesCustomTargetReferences ?? Enumerable.Empty <TargetAssembly>())
{
ScriptAssembly scriptAssemblyReference;
// Only add ScriptAssembly reference if the custom target assembly is dirty, e.g. is in targetToScriptAssembly dictionary
// Otherwise just add already compiled custom target assembly as precompiled reference.
if (targetToScriptAssembly.TryGetValue(customTargetAssembly, out scriptAssemblyReference))
{
scriptAssemblyReferences.Add(scriptAssemblyReference);
}
else
{
var customTargetAssemblyPath = customTargetAssembly.FullPath(settings.OutputDirectory, filenameSuffix);
// File might not exist if there are no scripts in the custom target assembly folder.
if (File.Exists(customTargetAssemblyPath))
{
references.Add(customTargetAssemblyPath);
}
}
}
}
// Add pre-compiled assemblies as references
PrecompiledAssembly[] precompiledAssembliesForReferences = assemblies.PrecompiledAssemblies ?? new PrecompiledAssembly[] {};
if (settings.OptionalUnityReferences != OptionalUnityReferences.None)
{
precompiledAssembliesForReferences = precompiledAssembliesForReferences.Where(x => x.OptionalUnityReferences == OptionalUnityReferences.None || ((targetAssembly.OptionalUnityReferences & x.OptionalUnityReferences & settings.OptionalUnityReferences) != 0)).ToArray();
}
var precompiledReferences = GetPrecompiledReferences(scriptAssembly, targetAssembly.Type, settings.CompilationOptions, targetAssembly.editorCompatibility, precompiledAssembliesForReferences);
references.AddRange(precompiledReferences);
if (buildingForEditor && assemblies.EditorAssemblyReferences != null)
{
references.AddRange(assemblies.EditorAssemblyReferences);
}
references.AddRange(MonoLibraryHelpers.GetSystemLibraryReferences(scriptAssembly.ApiCompatibilityLevel, scriptAssembly.BuildTarget, scriptAssembly.Language, buildingForEditor, scriptAssembly.Filename));
scriptAssembly.ScriptAssemblyReferences = scriptAssemblyReferences.ToArray();
scriptAssembly.References = references.ToArray();
}
static bool IsCompatibleWithPlatform(TargetAssembly assembly, ScriptAssemblySettings settings)
{
return(assembly.IsCompatibleFunc == null || assembly.IsCompatibleFunc(settings.BuildTarget, settings.CompilationOptions));
}
public static Dictionary <string, TargetAssembly> CreateTargetAssemblies(IEnumerable <CustomScriptAssembly> customScriptAssemblies)
{
if (customScriptAssemblies == null)
{
return(null);
}
var targetAssemblies = new List <TargetAssembly>();
var nameToTargetAssembly = new Dictionary <string, TargetAssembly>();
// Create TargetAssemblies
foreach (var customAssembly in customScriptAssemblies)
{
var lowerPathPrefix = Utility.FastToLower(customAssembly.PathPrefix);
var lowerAdditionalPathPrefixes = customAssembly.AdditionalPrefixes?.Select(Utility.FastToLower).ToArray();
var targetAssembly = new TargetAssembly(customAssembly.Name + ".dll",
customAssembly.AssemblyFlags,
TargetAssemblyType.Custom,
customAssembly.PathPrefix,
customAssembly.AdditionalPrefixes,
path => PathFilter(path, customAssembly.PathPrefix, lowerPathPrefix, customAssembly.AdditionalPrefixes, lowerAdditionalPathPrefixes),
(settings, defines) => customAssembly.IsCompatibleWith(settings.BuildTarget, settings.CompilationOptions, defines),
customAssembly.CompilerOptions)
{
ExplicitPrecompiledReferences = customAssembly.PrecompiledReferences?.ToList() ?? new List <string>(),
VersionDefines = customAssembly.VersionDefines != null
? customAssembly.VersionDefines.ToList() : new List <VersionDefine>(),
RootNamespace = customAssembly.RootNamespace,
ResponseFileDefines = customAssembly.ResponseFileDefines,
AsmDefPath = customAssembly.FilePath
};
targetAssemblies.Add(targetAssembly);
nameToTargetAssembly[customAssembly.Name] = targetAssembly;
}
var targetAssembliesEnumerator = targetAssemblies.GetEnumerator();
// Setup references for TargetAssemblies
foreach (var customAssembly in customScriptAssemblies)
{
targetAssembliesEnumerator.MoveNext();
var targetAssembly = targetAssembliesEnumerator.Current;
if (customAssembly.References == null)
{
continue;
}
foreach (var reference in customAssembly.References)
{
TargetAssembly referenceAssembly = null;
if (!nameToTargetAssembly.TryGetValue(reference, out referenceAssembly))
{
continue;
}
targetAssembly.References.Add(referenceAssembly);
}
}
var customTargetAssembliesDict = new Dictionary <string, TargetAssembly>();
foreach (var targetAssembly in targetAssemblies)
{
customTargetAssembliesDict[targetAssembly.Filename] = targetAssembly;
}
return(customTargetAssembliesDict);
}
internal static TargetAssembly[] CreatePredefinedTargetAssemblies()
{
var runtimeFirstPassAssemblies = new List <TargetAssembly>();
var runtimeAssemblies = new List <TargetAssembly>();
var editorFirstPassAssemblies = new List <TargetAssembly>();
var editorAssemblies = new List <TargetAssembly>();
var supportedLanguages = ScriptCompilers.SupportedLanguages;
var assemblies = new List <TargetAssembly>();
var scriptCompilerOptions = new ScriptCompilerOptions();
// Initialize predefined assembly targets
foreach (var language in supportedLanguages)
{
var languageName = language.GetLanguageName();
var runtimeFirstPass = new TargetAssembly("Assembly-" + languageName + "-firstpass" + ".dll",
language,
AssemblyFlags.FirstPass,
TargetAssemblyType.Predefined,
null,
FilterAssemblyInFirstpassFolder,
null,
scriptCompilerOptions);
var runtime = new TargetAssembly("Assembly-" + languageName + ".dll",
language,
AssemblyFlags.None,
TargetAssemblyType.Predefined,
null,
null,
null,
scriptCompilerOptions);
var editorFirstPass = new TargetAssembly("Assembly-" + languageName + "-Editor-firstpass" + ".dll",
language,
AssemblyFlags.EditorOnly | AssemblyFlags.FirstPass,
TargetAssemblyType.Predefined,
null,
FilterAssemblyInFirstpassEditorFolder,
IsCompatibleWithEditor,
scriptCompilerOptions)
{
OptionalUnityReferences = OptionalUnityReferences.TestAssemblies,
};
var editor = new TargetAssembly("Assembly-" + languageName + "-Editor" + ".dll",
language,
AssemblyFlags.EditorOnly,
TargetAssemblyType.Predefined,
null,
FilterAssemblyInEditorFolder,
IsCompatibleWithEditor,
scriptCompilerOptions)
{
OptionalUnityReferences = OptionalUnityReferences.TestAssemblies,
};
runtimeFirstPassAssemblies.Add(runtimeFirstPass);
runtimeAssemblies.Add(runtime);
editorFirstPassAssemblies.Add(editorFirstPass);
editorAssemblies.Add(editor);
assemblies.Add(runtimeFirstPass);
assemblies.Add(runtime);
assemblies.Add(editorFirstPass);
assemblies.Add(editor);
}
// Setup dependencies
// Runtime assemblies depend all first pass runtime assemblies
foreach (var assembly in runtimeAssemblies)
{
assembly.References.AddRange(runtimeFirstPassAssemblies);
}
// First pass editor assemblies depend on all first pass runtime assemblies
foreach (var assembly in editorFirstPassAssemblies)
{
assembly.References.AddRange(runtimeFirstPassAssemblies);
}
// Editor assemblies depend on all previous runtime and editor assemblies
foreach (var assembly in editorAssemblies)
{
assembly.References.AddRange(runtimeFirstPassAssemblies);
assembly.References.AddRange(runtimeAssemblies);
assembly.References.AddRange(editorFirstPassAssemblies);
}
return(assemblies.ToArray());
}
internal static void AddScriptAssemblyReferences(ref ScriptAssembly scriptAssembly, TargetAssembly targetAssembly, ScriptAssemblySettings settings,
CompilationAssemblies assemblies,
IDictionary <TargetAssembly, ScriptAssembly> targetToScriptAssembly, ICompilationSetupWarningTracker warningSink)
{
var scriptAssemblyReferences = new List <ScriptAssembly>(targetAssembly.References.Count);
var references = new List <string>();
bool buildingForEditor = settings.BuildingForEditor;
bool noEngineReferences = (targetAssembly.Flags & AssemblyFlags.NoEngineReferences) == AssemblyFlags.NoEngineReferences;
bool shouldProcessPredefinedCustomTargets = assemblies.CustomTargetAssemblies != null && (targetAssembly.Type & TargetAssemblyType.Predefined) == TargetAssemblyType.Predefined;
var predefinedCustomTargetReferences = Enumerable.Empty <TargetAssembly>();
if (shouldProcessPredefinedCustomTargets && assemblies.PredefinedAssembliesCustomTargetReferences != null)
{
predefinedCustomTargetReferences = assemblies.PredefinedAssembliesCustomTargetReferences;
}
var unityReferences = new Dictionary <string, string>();
// Add Unity assemblies (UnityEngine.dll, UnityEditor.dll) references, as long as the target
// doesn't specify that it doesn't want them.
if (!noEngineReferences)
{
// Add predefined custom target references in a hash-set for fast lookup
var predefinedCustomTargetRefs = new HashSet <string>(predefinedCustomTargetReferences.Select(x => x.Filename));
unityReferences = GetUnityReferences(scriptAssembly, targetAssembly, assemblies.UnityAssemblies, predefinedCustomTargetRefs, settings.CompilationOptions, UnityReferencesOptions.None);
references.AddRange(unityReferences.Values);
}
AddTestRunnerCustomReferences(ref targetAssembly, assemblies.CustomTargetAssemblies);
// Setup target assembly references
foreach (var reference in targetAssembly.References)
{
ScriptAssembly scriptAssemblyReference;
// If the assembly already showed up in the unity references, don't reference it here.
// This can happen when an assembly is configured as a unity assembly override, but
// overrides are disabled. The Unity assembly should take precedence in that case.
if (unityReferences.ContainsKey(reference.Filename))
{
continue;
}
// Add ScriptAssembly references to other dirty script assemblies that also need to be rebuilt.
if (targetToScriptAssembly.TryGetValue(reference, out scriptAssemblyReference))
{
System.Diagnostics.Debug.Assert(scriptAssemblyReference != null);
scriptAssemblyReferences.Add(scriptAssemblyReference);
}
}
// For predefined target assembly add references to custom target assemblies
if (shouldProcessPredefinedCustomTargets)
{
foreach (var customTargetAssembly in predefinedCustomTargetReferences)
{
ScriptAssembly scriptAssemblyReference;
// Only add ScriptAssembly reference if the custom target assembly is dirty, e.g. is in targetToScriptAssembly dictionary
// Otherwise just add already compiled custom target assembly as precompiled reference.
if (targetToScriptAssembly.TryGetValue(customTargetAssembly, out scriptAssemblyReference))
{
scriptAssemblyReferences.Add(scriptAssemblyReference);
}
}
}
// Add pre-compiled assemblies as references
var allPrecompiledAssemblies = assemblies.PrecompiledAssemblies ?? new Dictionary <string, PrecompiledAssembly>(0);
List <PrecompiledAssembly> precompiledReferences = new List <PrecompiledAssembly>(allPrecompiledAssemblies.Count);
var explicitPrecompiledReferences = new List <PrecompiledAssembly>(targetAssembly.ExplicitPrecompiledReferences.Count);
if ((targetAssembly.Flags & AssemblyFlags.ExplicitReferences) == AssemblyFlags.ExplicitReferences)
{
if (!noEngineReferences)
{
precompiledReferences.AddRange(allPrecompiledAssemblies
.Where(x => (x.Value.Flags & AssemblyFlags.UserAssembly) != AssemblyFlags.UserAssembly)
.Select(x => x.Value));
}
foreach (var explicitPrecompiledReference in targetAssembly.ExplicitPrecompiledReferences)
{
PrecompiledAssembly assembly;
if (allPrecompiledAssemblies.TryGetValue(explicitPrecompiledReference, out assembly))
{
explicitPrecompiledReferences.Add(assembly);
}
}
}
else
{
var precompiledAssemblies = allPrecompiledAssemblies.Values.Where(x => (x.Flags & AssemblyFlags.ExplicitlyReferenced) != AssemblyFlags.ExplicitlyReferenced).ToList();
// if noEngineReferences, add just the non-explicitly-referenced user assemblies
if (noEngineReferences)
{
precompiledReferences.AddRange(precompiledAssemblies.Where(x => (x.Flags & AssemblyFlags.UserAssembly) == AssemblyFlags.UserAssembly));
}
else
{
precompiledReferences.AddRange(precompiledAssemblies);
}
}
AddTestRunnerPrecompiledReferences(targetAssembly, allPrecompiledAssemblies, ref precompiledReferences);
var precompiledReferenceNames = GetPrecompiledReferences(scriptAssembly, targetAssembly.Type, settings.CompilationOptions, targetAssembly.editorCompatibility, precompiledReferences, explicitPrecompiledReferences, warningSink);
references.AddRange(precompiledReferenceNames);
if (buildingForEditor && assemblies.EditorAssemblyReferences != null)
{
references.AddRange(assemblies.EditorAssemblyReferences);
}
references.AddRange(MonoLibraryHelpers.GetSystemLibraryReferences(scriptAssembly.CompilerOptions.ApiCompatibilityLevel));
scriptAssembly.ScriptAssemblyReferences = scriptAssemblyReferences.ToArray();
scriptAssembly.References = references.ToArray();
}
protected bool Equals(TargetAssembly other)
{
return(string.Equals(Filename, other.Filename) && Flags == other.Flags && Type == other.Type);
}