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