public static ScriptAssembly[] GetAllScriptAssemblies(
Dictionary <string, string> allSourceFiles,
String projectDirectory,
ScriptAssemblySettings settings,
CompilationAssemblies assemblies,
ISafeModeInfo safeModeInfo,
TargetAssemblyType onlyIncludeType = TargetAssemblyType.Undefined,
Func <TargetAssembly, bool> targetAssemblyCondition = null,
ICompilationSetupWarningTracker warningSink = null)
{
if (allSourceFiles == null || allSourceFiles.Count == 0)
{
return(new ScriptAssembly[0]);
}
var targetAssemblyFiles = new Dictionary <TargetAssembly, DirtyTargetAssembly>();
foreach (var entry in allSourceFiles)
{
var scriptFile = entry.Key;
var assemblyName = entry.Value;
var targetAssembly = GetTargetAssembly(scriptFile, assemblyName, projectDirectory, assemblies.CustomTargetAssemblies);
if (targetAssembly == null)
{
continue;
}
if (!IsCompatibleWithPlatformAndDefines(targetAssembly, settings))
{
continue;
}
if (targetAssemblyCondition != null && !targetAssemblyCondition(targetAssembly))
{
continue;
}
// Optionally only include specific TargetAssemblyType assemblies.
if (onlyIncludeType != TargetAssemblyType.Undefined && targetAssembly.Type != onlyIncludeType)
{
continue;
}
DirtyTargetAssembly dirtyTargetAssembly;
if (!targetAssemblyFiles.TryGetValue(targetAssembly, out dirtyTargetAssembly))
{
dirtyTargetAssembly = new DirtyTargetAssembly();
targetAssemblyFiles[targetAssembly] = dirtyTargetAssembly;
}
dirtyTargetAssembly.SourceFiles.Add(AssetPath.Combine(projectDirectory, scriptFile));
}
return(ToScriptAssemblies(targetAssemblyFiles, settings, assemblies, warningSink, safeModeInfo));
}
internal static ScriptAssembly[] ToScriptAssemblies(
IDictionary <TargetAssembly, DirtyTargetAssembly> targetAssemblies,
ScriptAssemblySettings settings,
CompilationAssemblies assemblies, ICompilationSetupWarningTracker warningSink, ISafeModeInfo safeModeInfo)
{
var scriptAssemblies = new ScriptAssembly[targetAssemblies.Count];
var targetToScriptAssembly = new Dictionary <TargetAssembly, ScriptAssembly>();
int index = 0;
bool buildingForEditor = settings.BuildingForEditor;
var safeModeWhiteList = new HashSet <string>(safeModeInfo.GetWhiteListAssemblyNames());
foreach (var entry in targetAssemblies)
{
var targetAssembly = entry.Key;
var dirtyTargetAssembly = entry.Value;
var scriptAssembly = new ScriptAssembly();
// Setup TargetAssembly -> ScriptAssembly mapping for converting references
scriptAssemblies[index] = scriptAssembly;
targetToScriptAssembly[targetAssembly] = scriptAssemblies[index++];
// Setup ScriptAssembly
scriptAssembly.Flags = targetAssembly.Flags;
scriptAssembly.BuildTarget = settings.BuildTarget;
scriptAssembly.OriginPath = targetAssembly.PathPrefix;
scriptAssembly.Filename = targetAssembly.Filename;
scriptAssembly.SkipCodeGen = safeModeWhiteList.Contains(targetAssembly.Filename);
scriptAssembly.RootNamespace = targetAssembly.Type == TargetAssemblyType.Predefined ? settings.ProjectRootNamespace : targetAssembly.RootNamespace;
scriptAssembly.OutputDirectory = settings.OutputDirectory;
scriptAssembly.Defines = targetAssembly.Defines == null ? s_CSharpVersionDefines : targetAssembly.Defines.Concat(s_CSharpVersionDefines).ToArray();
scriptAssembly.Files = dirtyTargetAssembly.SourceFiles.ToArray();
scriptAssembly.TargetAssemblyType = targetAssembly.Type;
scriptAssembly.AsmDefPath = targetAssembly.AsmDefPath;
if (scriptAssembly.TargetAssemblyType == TargetAssemblyType.Predefined)
{
scriptAssembly.CompilerOptions = new ScriptCompilerOptions(settings.PredefinedAssembliesCompilerOptions);
}
else
{
scriptAssembly.CompilerOptions = targetAssembly.CompilerOptions;
}
scriptAssembly.CompilerOptions.RoslynAnalyzerDllPaths = new string[0];
scriptAssembly.CompilerOptions.RoslynAnalyzerRulesetPath = string.Empty;
scriptAssembly.CompilerOptions.AdditionalCompilerArguments = settings.AdditionalCompilerArguments;
var editorOnlyTargetAssembly = (targetAssembly.Flags & AssemblyFlags.EditorOnly) == AssemblyFlags.EditorOnly;
if (editorOnlyTargetAssembly)
{
scriptAssembly.CompilerOptions.ApiCompatibilityLevel = ApiCompatibilityLevel.NET_Unity_4_8;
}
else
{
scriptAssembly.CompilerOptions.ApiCompatibilityLevel = settings.PredefinedAssembliesCompilerOptions.ApiCompatibilityLevel;
}
if ((settings.CompilationOptions & EditorScriptCompilationOptions.BuildingUseDeterministicCompilation) == EditorScriptCompilationOptions.BuildingUseDeterministicCompilation)
{
scriptAssembly.CompilerOptions.UseDeterministicCompilation = true;
}
else
{
scriptAssembly.CompilerOptions.UseDeterministicCompilation = false;
}
scriptAssembly.CompilerOptions.CodeOptimization = settings.CodeOptimization;
}
// Don't add the auto-referenced engine assemblies if the assembly either has the flag set, or
// is a codegen assembly
AutoReferencedPackageAssemblies.AddReferences(assemblies.CustomTargetAssemblies, settings.CompilationOptions,
t =>
{
var hasNoEngineReferencesFlag = (t.Flags & AssemblyFlags.NoEngineReferences) == AssemblyFlags.NoEngineReferences;
if (hasNoEngineReferencesFlag)
{
return(false);
}
return(!UnityCodeGenHelpers.IsCodeGen(t.Filename));
});
// Setup ScriptAssembly references
index = 0;
foreach (var entry in targetAssemblies)
{
var scriptAssembly = scriptAssemblies[index++];
AddScriptAssemblyReferences(ref scriptAssembly, entry.Key, settings, assemblies, targetToScriptAssembly, warningSink);
if (UnityCodeGenHelpers.IsCodeGen(entry.Key.Filename) ||
UnityCodeGenHelpers.IsCodeGenTest(entry.Key.Filename) ||
CompilationPipelineCommonHelper.ShouldAdd(entry.Key.Filename))
{
CompilationPipelineCommonHelper.UpdateScriptAssemblyReference(ref scriptAssembly);
}
if (!buildingForEditor)
{
PlatformSupportModuleHelpers.AddAdditionalPlatformSupportData(settings.CompilationExtension, ref scriptAssembly);
}
}
if ((settings.CompilationOptions & EditorScriptCompilationOptions.BuildingWithRoslynAnalysis) != 0)
{
var analyzers = assemblies.RoslynAnalyzerDllPaths;
foreach (var a in analyzers)
{
var targetAssemblyOwningAnalyzer = assemblies.CustomTargetAssemblies.Values
.OrderBy(c => c.PathFilter(a)).LastOrDefault();
if (targetAssemblyOwningAnalyzer?.PathFilter(a) <= 0)
{
targetAssemblyOwningAnalyzer = null;
}
foreach (var scriptAssembly in scriptAssemblies)
{
if (ShouldUseAnalyzerForScriptAssembly(scriptAssembly, targetAssemblyOwningAnalyzer))
{
scriptAssembly.CompilerOptions.RoslynAnalyzerDllPaths = scriptAssembly.CompilerOptions.RoslynAnalyzerDllPaths.Concat(new[] { a }).ToArray();
scriptAssembly.CompilerOptions.RoslynAnalyzerRulesetPath =
scriptAssembly.TargetAssemblyType == TargetAssemblyType.Predefined
? RuleSetFileCache.GetRuleSetFilePathInRootFolder(Path.ChangeExtension(scriptAssembly.Filename, null))
: RuleSetFileCache.GetPathForAssembly(scriptAssembly.OriginPath);
}
}
}
}
return(scriptAssemblies);
}
