public DefaultBuildEnvironment(IPlan plan, ITargetDescription description, TaskMap<ModuleName, ITarget> taskMap, CancellationToken token)
{
if (taskMap == null)
throw new System.ArgumentNullException("taskMap");
if (description == null)
throw new System.ArgumentNullException("description");
if ((object) plan == null)
throw new System.ArgumentNullException("plan");
_token = token;
_plan = plan;
_taskMap = taskMap;
_description = description;
var externals = new List<SymbolInfo>();
foreach (var name in description.Dependencies)
{
var d = taskMap[name].Value.Result;
if (d.Symbols == null) continue;
var origin = new SymbolOrigin.ModuleTopLevel(name, NoSourcePosition.Instance);
externals.AddRange(from decl in d.Symbols
select new SymbolInfo(decl.Value, origin, decl.Key));
}
_externalSymbols = SymbolStore.Create(conflictUnionSource: externals);
_compilationEngine = new Engine();
_module = Module.Create(description.Name);
}
protected void EnsureIsResolved(ITargetDescription description)
{
if (HasUnresolvedDependencies(description))
{
var missing = description.Dependencies.Where(d => !TargetDescriptions.Contains(d)).ToEnumerationString();
Plan.Trace.TraceEvent(TraceEventType.Error, 0,
"Failed to resolve the following dependencies of target {0}: {1}", description, missing);
throw new BuildException(
string.Format("Not all dependencies of target named {0} have been resolved. The following modules are missing: {1}",
description.Name, missing), description);
}
}
public static void ThrowIfFailed(this ITarget target, ITargetDescription description)
{
if (target == null)
throw new ArgumentNullException("target");
if (description == null)
throw new ArgumentNullException("description");
if (target.Exception != null)
throw target.Exception;
else if (target.Messages.Any(m => m.Severity == MessageSeverity.Error))
throw new BuildFailureException(description,
"There {2} {0} {1} while translating " + description.Name + ".",
target.Messages);
}
protected override Task<ITarget> BuildTargetAsync(Task<IBuildEnvironment> buildEnvironment, ITargetDescription description, Dictionary<ModuleName, Task<ITarget>> dependencies, CancellationToken token)
{
return
base.BuildTargetAsync(buildEnvironment, description, dependencies, token).ContinueWith(
t =>
{
var actualTarget = t.Result;
if ((actualTarget is ProvidedTarget))
return actualTarget;
var providedTarget = new ProvidedTarget(description, actualTarget);
TargetDescriptions.Replace(description, providedTarget);
return (ITarget) providedTarget;
}, token,
TaskContinuationOptions.ExecuteSynchronously,
TaskScheduler.Current);
}
public BuildException(string message, [CanBeNull] ITargetDescription relatedTarget, Exception inner) : base(message, inner)
{
_relatedTarget = relatedTarget;
}
public BuildException(ITargetDescription relatedTarget)
{
_relatedTarget = relatedTarget;
}
public ProvidedTarget(ITargetDescription description, ITarget result)
: this(result.Module, description.Dependencies, result.Symbols, result.Resources, result.Messages, description.BuildMessages, result.Exception)
{
}
protected bool HasUnresolvedDependencies(ITargetDescription targetDescription)
{
return !targetDescription.Dependencies.All(TargetDescriptions.Contains);
}
protected virtual Task<ITarget> BuildTargetAsync(Task<IBuildEnvironment> buildEnvironment, ITargetDescription description, Dictionary<ModuleName, Task<ITarget>> dependencies, CancellationToken token)
{
var buildTask = description.BuildAsync(buildEnvironment.Result, dependencies, token);
Debug.Assert(buildTask != null, "Task for building target is null.", string.Format("{0}.BuildAsync returned null instead of a Task.", description.GetType().Name));
return buildTask;
}
protected Task<ITarget> BuildWithMapAsync(ITargetDescription targetDescription, TaskMap<ModuleName, ITarget> taskMap, CancellationToken token)
{
return taskMap.GetOrAdd(targetDescription.Name,
name =>
{
Plan.Trace.TraceEvent(TraceEventType.Verbose, 0, "Request build of {0} and its dependencies.",
targetDescription);
return
Task.Factory.StartNew(() => _buildTaskImpl(targetDescription, taskMap, token, name), token)
.Unwrap();
});
}
private Task<ITarget> _buildTaskImpl(ITargetDescription targetDescription, TaskMap<ModuleName, ITarget> taskMap, CancellationToken token,
ModuleName name)
{
var desc = TargetDescriptions[name];
var deps =
desc.Dependencies.Select(
depName =>
new KeyValuePair<ModuleName, Task<ITarget>>(
depName,
BuildWithMapAsync(
TargetDescriptions[depName],
taskMap, token)));
var depMap = new Dictionary<ModuleName, Task<ITarget>>();
depMap.AddRange(deps);
token.ThrowIfCancellationRequested();
var buildTask = GetBuildEnvironmentAsync(taskMap, desc,
token)
.ContinueWith(bet =>
{
var instance =
new Application(
bet.Result.Module);
Plan.Trace.TraceEvent(
TraceEventType.Verbose, 0,
"Linking compile-time dependencies for module {0}.",
bet.Result.Module.Name);
_linkDependencies(taskMap,
instance, targetDescription,
token);
token
.ThrowIfCancellationRequested
();
return BuildTargetAsync(bet, desc,
depMap, token);
}, token);
return buildTask.Unwrap();
}
protected virtual IBuildEnvironment GetBuildEnvironment(TaskMap<ModuleName, ITarget> taskMap, ITargetDescription description, CancellationToken token)
{
Plan.Trace.TraceEvent(TraceEventType.Verbose, 0, "Get build environment for {0}.", description);
var buildEnvironment = new DefaultBuildEnvironment(this, description, taskMap, token);
return buildEnvironment;
}
protected Task<IBuildEnvironment> GetBuildEnvironmentAsync(TaskMap<ModuleName, ITarget> taskMap, ITargetDescription description, CancellationToken token)
{
if (description.Dependencies.Count == 0)
{
var tcs = new TaskCompletionSource<IBuildEnvironment>();
tcs.SetResult(GetBuildEnvironment(taskMap, description, token));
return tcs.Task;
}
else
// Note how the lambda expression doesn't actually depend on the result (directly)
// the continue all makes sure that we're not wasting a thread that blocks on Task.Result
// GetBuildEnvironment can access the results via the taskMap.
return Task.Factory.ContinueWhenAll(description.Dependencies.Select(d => taskMap[d].Value).ToArray(),
_ => GetBuildEnvironment(taskMap, description, token));
}
internal static void _LinkDependenciesImpl(IPlan plan, TaskMap<ModuleName, ITarget> taskMap, Application instance,
ITargetDescription instanceDescription, CancellationToken token)
{
foreach (var dependency in instanceDescription.Dependencies)
{
if (instance.IsLinkedTo(dependency))
continue;
var dependencyDescription = plan.TargetDescriptions[dependency];
token.ThrowIfCancellationRequested();
var dependencyInstance = new Application(taskMap[dependency].Value.Result.Module);
Application.Link(instance, dependencyInstance);
_LinkDependenciesImpl(plan, taskMap, dependencyInstance, dependencyDescription, token);
}
}
private void _linkDependencies(TaskMap<ModuleName, ITarget> taskMap, Application instance, ITargetDescription instanceDescription, CancellationToken token)
{
_LinkDependenciesImpl(this, taskMap, instance, instanceDescription, token);
}
public BuildFailureException(ITargetDescription target, string messageFormat, IEnumerable<Message> messages, Exception inner)
: base(_makeErrorMessage(messages, messageFormat), target,inner)
{
_messages.AddRange(messages);
}
