public ParameterizedType(ITypeDefinition genericType, IEnumerable <IType> typeArguments)
{
if (genericType == null)
{
throw new ArgumentNullException("genericType");
}
if (typeArguments == null)
{
throw new ArgumentNullException("typeArguments");
}
this.genericType = genericType;
this.typeArguments = typeArguments.ToArray(); // copy input array to ensure it isn't modified
if (this.typeArguments.Length == 0)
{
throw new ArgumentException("Cannot use ParameterizedType with 0 type arguments.");
}
if (genericType.TypeParameterCount != this.typeArguments.Length)
{
throw new ArgumentException("Number of type arguments must match the type definition's number of type parameters");
}
for (int i = 0; i < this.typeArguments.Length; i++)
{
if (this.typeArguments[i] == null)
{
throw new ArgumentNullException("typeArguments[" + i + "]");
}
ICompilationProvider p = this.typeArguments[i] as ICompilationProvider;
if (p != null && p.Compilation != genericType.Compilation)
{
throw new InvalidOperationException("Cannot parameterize a type with type arguments from a different compilation.");
}
}
}
public BicepCompilationManager(ILanguageServerFacade server, ICompilationProvider provider, IWorkspace workspace, IFileResolver fileResolver, IModuleRestoreScheduler scheduler)
{
this.server = server;
this.provider = provider;
this.workspace = workspace;
this.fileResolver = fileResolver;
this.scheduler = scheduler;
}
public CakeSourceGeneratorService(
IMetadataGeneratorService metadataGeneratorService,
IMetadataReferenceLoader metadataReferenceLoader,
ICompilationProvider compilationProvider)
{
_metadataGeneratorService = metadataGeneratorService ?? throw new ArgumentNullException(nameof(metadataGeneratorService));
_metadataReferenceLoader = metadataReferenceLoader ?? throw new ArgumentNullException(nameof(metadataReferenceLoader));
_compilationProvider = compilationProvider ?? throw new ArgumentNullException(nameof(compilationProvider));
}
public ArrayType(ICompilation compilation, IType elementType, int dimensions = 1) : base(elementType)
{
if (compilation == null)
{
throw new ArgumentNullException("compilation");
}
if (dimensions <= 0)
{
throw new ArgumentOutOfRangeException("dimensions", dimensions, "dimensions must be positive");
}
this.compilation = compilation;
this.dimensions = dimensions;
ICompilationProvider p = elementType as ICompilationProvider;
if (p != null && p.Compilation != compilation)
{
throw new InvalidOperationException("Cannot create an array type using a different compilation from the element type.");
}
}
public BicepCompilationManager(
ILanguageServerFacade server,
ICompilationProvider provider,
IWorkspace workspace,
IFileResolver fileResolver,
IModuleRestoreScheduler scheduler,
IConfigurationManager configurationManager,
ITelemetryProvider telemetryProvider,
ILinterRulesProvider LinterRulesProvider)
{
this.server = server;
this.provider = provider;
this.workspace = workspace;
this.fileResolver = fileResolver;
this.scheduler = scheduler;
this.configurationManager = configurationManager;
this.TelemetryProvider = telemetryProvider;
this.LinterRulesProvider = LinterRulesProvider;
}
public MetadataGenerator(
ICakeSourceGeneratorService cakeSourceGenerator,
ICakeSyntaxRewriterService cakeSyntaxRewriterService,
IPackageManager packageManager,
IDependencyResolver dependencyResolver,
IPackageAssemblyResolver packageAssemblyResolver,
ICompiler compiler,
IMetadataReferenceLoader metadataReferenceLoader,
ICompilationProvider compilationProvider,
IFileSystem fileSystem)
{
_cakeSourceGenerator = cakeSourceGenerator ?? throw new ArgumentNullException(nameof(cakeSourceGenerator));
_cakeSyntaxRewriterService = cakeSyntaxRewriterService ?? throw new ArgumentNullException(nameof(cakeSyntaxRewriterService));
_packageManager = packageManager ?? throw new ArgumentNullException(nameof(packageManager));
_dependencyResolver = dependencyResolver ?? throw new ArgumentNullException(nameof(dependencyResolver));
_packageAssemblyResolver = packageAssemblyResolver ?? throw new ArgumentNullException(nameof(packageAssemblyResolver));
_compiler = compiler ?? throw new ArgumentNullException(nameof(compiler));
_metadataReferenceLoader = metadataReferenceLoader ?? throw new ArgumentNullException(nameof(metadataReferenceLoader));
_compilationProvider = compilationProvider ?? throw new ArgumentNullException(nameof(compilationProvider));
_fileSystem = fileSystem ?? throw new ArgumentNullException(nameof(fileSystem));
}
public BicepCompilationManager(ILanguageServerFacade server, ICompilationProvider provider)
{
this.server = server;
this.provider = provider;
}
public CakeSyntaxRewriterService(ICompilationProvider compilationProvider, IEnumerable <ISyntaxRewriterService> metadataRewriterServices)
{
_compilationProvider = compilationProvider ?? throw new ArgumentNullException(nameof(compilationProvider));
_metadataRewriterServices = metadataRewriterServices?.OrderBy(service => service.Order) ?? throw new ArgumentNullException(nameof(metadataRewriterServices));
}
public GitStatusDisplay(
IRunnableStateProvider runnableStateProvider,
ICompilationProvider compilationProvider,
IPatcherRunnabilityCliState runnabilityCliState,
IDriverRepositoryPreparationFollower driverRepositoryPreparation)
{
StatusDisplay = Observable.CombineLatest(
driverRepositoryPreparation.DriverInfo,
runnableStateProvider.WhenAnyValue(x => x.State),
compilationProvider.State,
runnabilityCliState.Runnable,
(driver, runnable, comp, runnability) =>
{
if (driver.RunnableState.Failed)
{
if (driver.IsHaltingError)
{
return(new StatusRecord(
Text: "Blocking Error",
Processing: false,
Blocking: true,
Command: null));
}
return(new StatusRecord(
Text: "Analyzing repository",
Processing: true,
Blocking: false,
Command: null));
}
if (runnable.RunnableState.Failed)
{
if (runnable.IsHaltingError)
{
return(new StatusRecord(
Text: "Blocking Error",
Processing: false,
Blocking: true,
Command: null));
}
return(new StatusRecord(
Text: "Checking out desired state",
Processing: true,
Blocking: false,
Command: null));
}
if (comp.RunnableState.Failed)
{
if (comp.IsHaltingError)
{
return(new StatusRecord(
Text: "Blocking Error",
Processing: false,
Blocking: true,
Command: null));
}
return(new StatusRecord(
Text: "Compiling",
Processing: true,
Blocking: false,
Command: null));
}
if (runnability.RunnableState.Failed)
{
if (runnability.IsHaltingError)
{
return(new StatusRecord(
Text: "Blocking Error",
Processing: false,
Blocking: true,
Command: null));
}
return(new StatusRecord(
Text: "Checking runnability",
Processing: true,
Blocking: false,
Command: null));
}
return(new StatusRecord(
Text: "Ready",
Processing: false,
Blocking: false,
Command: null));
})
.Replay(1)
.RefCount();
}
public GitPatcherVm(
IGithubPatcherIdentifier ident,
IPatcherNameVm nameVm,
IProfileDisplayControllerVm selPatcher,
IConfirmationPanelControllerVm confirmation,
ISelectedProjectInputVm selectedProjectInput,
IGitRemoteRepoPathInputVm remoteRepoPathInputVm,
INavigateTo navigate,
IAvailableTags availableTags,
ILockToCurrentVersioning lockToCurrentVersioning,
IAvailableProjects availableProjects,
ICompilationProvider compilationProvider,
IBaseRepoDirectoryProvider baseRepoDir,
IGitStatusDisplay gitStatusDisplay,
IDriverRepoDirectoryProvider driverRepoDirectoryProvider,
IRunnerRepoDirectoryProvider runnerRepoDirectoryProvider,
IGetRepoPathValidity getRepoPathValidity,
IRepoClonesValidStateVm repoClonesValid,
INugetDiffProviderVm nugetDiff,
IGitPatcherState state,
ILogger logger,
IRunnableStateProvider runnableStateProvider,
ILifetimeScope scope,
IGitPatcherTargetingVm patcherTargeting,
ICheckoutInputProvider checkoutInputProvider,
IGitNugetTargetingVm nugetTargetingVm,
IUpdateAllCommand updateAllCommand,
IAttemptedCheckout attemptedCheckout,
IPatcherIdProvider idProvider,
ICopyOverExtraData copyOverExtraData,
PatcherRenameActionVm.Factory renameFactory,
DeleteUserData deleteUserData,
PatcherUserSettingsVm.Factory settingsVmFactory,
GithubPatcherSettings?settings = null)
: base(
scope, nameVm, selPatcher,
confirmation, idProvider, renameFactory, settings)
{
_logger = logger;
_copyOverExtraData = copyOverExtraData;
SelectedProjectInput = selectedProjectInput;
RemoteRepoPathInput = remoteRepoPathInputVm;
Locking = lockToCurrentVersioning;
RepoClonesValid = repoClonesValid;
NugetDiff = nugetDiff;
PatcherTargeting = patcherTargeting;
NugetTargeting = nugetTargetingVm;
UpdateAllCommand = updateAllCommand;
DeleteUserDataCommand = ReactiveCommand.Create(deleteUserData.Delete);
ID = ident.Id;
CopyInSettings(settings);
LocalDriverRepoDirectory = driverRepoDirectoryProvider.Path.Path;
LocalRunnerRepoDirectory = runnerRepoDirectoryProvider.Path.Path;
_repoValidity = getRepoPathValidity.RepoPath
.Select(r => r.RunnableState)
.ToGuiProperty(this, nameof(RepoValidity), deferSubscription: true);
AvailableProjects = availableProjects.Projects;
AvailableTags = availableTags.Tags;
_attemptedCheckout = checkoutInputProvider.Input
.Select(attemptedCheckout.Attempted)
.ToGuiProperty(this, nameof(AttemptedCheckout), deferSubscription: true);
_runnableData = runnableStateProvider.WhenAnyValue(x => x.State.Item)
.ToGuiProperty(this, nameof(RunnableData), default(RunnerRepoInfo?), deferSubscription: true);
_state = state.State
.ToGuiProperty(this, nameof(State), new ConfigurationState(ErrorResponse.Fail("Evaluating"))
{
IsHaltingError = false
}, deferSubscription: true);
OpenGitPageCommand = ReactiveCommand.Create(
canExecute: this.WhenAnyValue(x => x.RepoValidity)
.Select(x => x.Succeeded),
execute: () => navigate.Navigate(RemoteRepoPathInput.RemoteRepoPath));
OpenGitPageToVersionCommand = ReactiveCommand.Create(
canExecute: this.WhenAnyFallback(x => x.RunnableData)
.Select(x => x != null),
execute: () =>
{
try
{
if (RunnableData is not {
} runnable)
{
return;
}
navigate.Navigate(Path.Combine(RemoteRepoPathInput.RemoteRepoPath, "tree", runnable.Target.Target));
}
catch (Exception ex)
{
_logger.Error(ex, "Error opening Git webpage");
}
});
NavigateToInternalFilesCommand = ReactiveCommand.Create(() => navigate.Navigate(baseRepoDir.Path));
PatcherSettings = settingsVmFactory(
false,
compilationProvider.State.Select(c =>
{
if (c.RunnableState.Failed)
{
return(new PatcherUserSettingsVm.Inputs(c.RunnableState.BubbleFailure <FilePath>(), null, default));
}
return(new PatcherUserSettingsVm.Inputs(GetResponse <FilePath> .Succeed(c.Item.ProjPath), c.Item.TargetVersions.Synthesis, c.Item.MetaPath));
})
.DistinctUntilChanged())
.DisposeWith(this);
_statusDisplay = gitStatusDisplay.StatusDisplay
.ToGuiProperty(this, nameof(StatusDisplay),
new StatusRecord(
Text: "Initializing",
Processing: false,
Blocking: false,
Command: null), deferSubscription: true);
SetToLastSuccessfulRunCommand = ReactiveCommand.Create(
canExecute: this.WhenAnyValue(x => x.LastSuccessfulRun)
.Select(x =>
{
return(x != null &&
!x.TargetRepo.IsNullOrWhitespace() &&
!x.ProjectSubpath.IsNullOrWhitespace() &&
!x.Commit.IsNullOrWhitespace() &&
!x.MutagenVersion.IsNullOrWhitespace() &&
!x.SynthesisVersion.IsNullOrWhitespace());
}),
execute: () =>
{
if (LastSuccessfulRun == null)
{
return;
}
RemoteRepoPathInput.RemoteRepoPath = LastSuccessfulRun.TargetRepo;
this.SelectedProjectInput.ProjectSubpath = LastSuccessfulRun.ProjectSubpath;
this.PatcherTargeting.TargetCommit = LastSuccessfulRun.Commit;
this.NugetTargeting.ManualMutagenVersion = LastSuccessfulRun.MutagenVersion;
this.NugetTargeting.ManualSynthesisVersion = LastSuccessfulRun.SynthesisVersion;
this.PatcherTargeting.PatcherVersioning = PatcherVersioningEnum.Commit;
this.NugetTargeting.SynthesisVersioning = PatcherNugetVersioningEnum.Manual;
this.NugetTargeting.MutagenVersioning = PatcherNugetVersioningEnum.Manual;
});
}
public MemoryCompiler(ICompilationProvider compilationProvider)
{
_compilationProvider = compilationProvider;
}
public BicepCompilationManager(ILanguageServerFacade server, ICompilationProvider provider, IWorkspace workspace)
{
this.server = server;
this.provider = provider;
this.workspace = workspace;
}
public PatcherRunnabilityCliState(
ICompilationProvider compilationProvider,
IProfileDataFolderVm dataFolder,
IProfileLoadOrder loadOrder,
IExecuteRunnabilityCheck checkRunnability,
ITemporaryLoadOrderProvider temporaryLoadOrderProvider,
ILogger logger)
{
Runnable = Observable.CombineLatest(
compilationProvider.State,
dataFolder.WhenAnyValue(x => x.Path),
loadOrder.LoadOrder.Connect()
.QueryWhenChanged()
.StartWith(ListExt.Empty <ReadOnlyModListingVM>()),
(comp, data, loadOrder) => (comp, data, loadOrder))
.Select(i =>
{
return(Observable.Create <ConfigurationState <RunnerRepoInfo> >(async(observer, cancel) =>
{
if (i.comp.RunnableState.Failed)
{
observer.OnNext(i.comp);
return;
}
logger.Information("Checking runnability");
// Return early with the values, but mark not complete
observer.OnNext(new ConfigurationState <RunnerRepoInfo>(i.comp.Item)
{
IsHaltingError = false,
RunnableState = ErrorResponse.Fail("Checking runnability")
});
try
{
using var tmpLoadOrder = temporaryLoadOrderProvider.Get(
i.loadOrder.Select <ReadOnlyModListingVM, IModListingGetter>(lvm => lvm));
var runnability = await checkRunnability.Check(
path: i.comp.Item.ProjPath,
directExe: false,
cancel: cancel,
buildMetaPath: i.comp.Item.MetaPath,
loadOrderPath: tmpLoadOrder.File).ConfigureAwait(false);
if (runnability.Failed)
{
logger.Information($"Checking runnability failed: {runnability.Reason}");
observer.OnNext(runnability.BubbleFailure <RunnerRepoInfo>());
return;
}
// Return things again, without error
logger.Information("Checking runnability succeeded");
observer.OnNext(i.comp);
}
catch (Exception ex)
{
var str = $"Error checking runnability on runner repository: {ex}";
logger.Error(str);
observer.OnNext(ErrorResponse.Fail(str).BubbleFailure <RunnerRepoInfo>());
}
observer.OnCompleted();
}));
})
.Switch()
.Replay(1)
.RefCount();
}
