private IProjectFile GetOrCreateSameDestinationFile(
[NotNull] IProjectModelTransactionCookie cookie,
[NotNull] IT4File file,
[NotNull] string destinationName
)
{
Locks.AssertWriteAccessAllowed();
var existingFile = GetSameDestinationFile(file, destinationName);
if (existingFile != null)
{
return(existingFile);
}
return(CreateSameDestinationFile(cookie, file, destinationName));
}
private IProjectFile GetSameDestinationFile([NotNull] IT4File file, [NotNull] string temporaryName)
{
Locks.AssertWriteAccessAllowed();
var sourceFile = file.PhysicalPsiSourceFile.NotNull();
var candidates = sourceFile
.ToProjectFile()
?.ParentFolder
?.GetSubItems(temporaryName)
.ToList()
.OfType <IProjectFile>()
.AsList();
Assertion.AssertNotNull(candidates, "candidates != null");
Assertion.Assert(candidates.Count <= 1, "candidates.Value.Length <= 1");
return(candidates.SingleOrDefault());
}
private FileSystemPath ResolveBaseReference(
[NotNull] IT4File file,
[NotNull] string assemblyName
)
{
var resolved = AssemblyReferenceResolver.Resolve(assemblyName, file.LogicalPsiSourceFile);
if (resolved != null)
{
return(resolved);
}
var node = FindSuitableNodeForErrorReporting(file);
string message = $"Could not find standard assembly: {assemblyName}";
throw new T4OutputGenerationException(T4FailureRawData.FromElement(node, message));
}
public FileSystemPath GetTemporaryExecutableLocation(IT4File file)
{
var projectFile = file.PhysicalPsiSourceFile.ToProjectFile();
var project = projectFile?.GetProject();
if (project == null)
{
return(FileSystemPath.Empty);
}
var relativePath = projectFile.Location.MakeRelativeTo(project.Location.Parent);
var ttLocation = project.GetIntermediateDirectory(project.GetCurrentTargetFrameworkId())
.Combine("TextTemplating")
.Combine(relativePath);
return(ttLocation.Parent.Combine(ttLocation.Name.WithoutExtension()).Combine("GeneratedTransformation.exe"));
}
public void Debug(IT4File file)
{
Logger.Verbose("Trying to debug a file");
lock (ExecutionLocker)
{
if (IsExecutionRunning(file))
{
ShowNotification();
return;
}
RememberExecution(file, false);
}
Model.RequestDebug.Start(new T4ExecutionRequest(GetT4FileLocation(file), true));
}
public void ExecuteSilently(IT4File file)
{
Logger.Verbose("Trying to execute a file silently");
lock (ExecutionLocker)
{
if (IsExecutionRunning(file))
{
ShowNotification();
return;
}
RememberExecution(file, true);
}
Model.RequestExecution.Start(new T4ExecutionRequest(GetT4FileLocation(file), false));
}
public IEnumerable <IProject> GetProjectDependencies(IT4File file)
{
file.AssertContainsNoIncludeContext();
var sourceFile = file.LogicalPsiSourceFile.NotNull();
var projectFile = sourceFile.ToProjectFile().NotNull();
var psiModule = sourceFile.PsiModule;
var resolveContext = projectFile.SelectResolveContext();
using (CompilationContextCookie.GetOrCreate(resolveContext))
{
return(PsiModules
.GetModuleReferences(psiModule)
.Select(it => it.Module)
.OfType <IProjectPsiModule>()
.Select(it => it.Project)
.AsList());
}
}
public T4CSharpCodeBehindIntermediateConverter(
[NotNull] IT4File file,
[NotNull] IT4GeneratedClassNameProvider classNameProvider,
bool isRoot = true
) : base(file, classNameProvider)
{
IsRoot = isRoot;
if (IsRoot)
{
TransformTextMethodName = DefaultTransformTextMethodName;
TransformTextAttributes = "";
}
else
{
TransformTextMethodName = DefaultTransformTextMethodName + Guid.NewGuid().ToString("N");
TransformTextAttributes = "[__ReSharperSynthetic]";
}
}
private static Pair <IT4File, IFile> GetFiles([NotNull] IPsiSourceFile sourceFile, DocumentRange documentRange)
{
IT4File primaryFile = null;
IFile secondaryFile = null;
foreach ((IFile file, _) in sourceFile.EnumerateIntersectingPsiFiles(documentRange))
{
if (file is IT4File t4File)
{
primaryFile = t4File;
}
else
{
secondaryFile = file;
}
}
return(Pair.Of(primaryFile, secondaryFile));
}
protected override T4IncludeData Build(IT4File file)
{
if (file.PhysicalPsiSourceFile?.IsBeingIndirectlyUpdated() == true)
{
// Since the contents of this file did not change,
// the list of its direct includes did not change either,
// so there's no point in doing anything here
return(null);
}
return(new T4IncludeData(file
.GetThisAndChildrenOfType <IT4IncludeDirective>()
.Where(directive => directive.IsVisibleInDocument())
.Select(directive => IncludeResolver.ResolvePath(directive.ResolvedPath))
.Where(path => !path.IsEmpty)
.Distinct()
.ToList()
));
}
private static Pair <IT4File, IFile> GetFiles([NotNull] IPsiSourceFile sourceFile, DocumentRange documentRange)
{
IT4File primaryFile = null;
IFile secondaryFile = null;
foreach (Pair <IFile, TreeTextRange> pair in sourceFile.EnumerateIntersectingPsiFiles(documentRange))
{
var t4File = pair.First as IT4File;
if (t4File != null)
{
primaryFile = t4File;
}
else
{
secondaryFile = pair.First;
}
}
return(Pair.Of(primaryFile, secondaryFile));
}
protected void DoInvalidateAssemblies([NotNull] IT4File t4File)
{
var sourceFile = t4File.PhysicalPsiSourceFile;
if (sourceFile?.LanguageType.Is <T4ProjectFileType>() != true)
{
return;
}
var newData = new T4DeclaredAssembliesInfo(t4File);
var existingDeclaredAssembliesInfo = sourceFile.GetDeclaredAssembliesInfo();
sourceFile.SetDeclaredAssembliesInfo(newData);
var diff = newData.DiffWith(existingDeclaredAssembliesInfo);
if (diff == null)
{
return;
}
FileDataChanged.Fire(Pair.Of(sourceFile, diff));
}
private void RemoveLastGenOutputIfDifferent(
[NotNull] IT4File file,
[NotNull] IProjectModelTransactionCookie cookie,
[NotNull] FileSystemPath destinationLocation
)
{
var projectFile = file.PhysicalPsiSourceFile?.ToProjectFile();
if (projectFile == null)
{
return;
}
foreach (var suspect in TemplateMetadataManager
.FindLastGenOutput(projectFile)
.Where(it => it.Location != destinationLocation)
)
{
cookie.Remove(suspect);
}
}
private static Pair <IT4File, IFile> GetFiles([NotNull] IPsiSourceFile sourceFile, DocumentRange documentRange)
{
IT4File primaryFile = null;
IFile secondaryFile = null;
foreach (IFile file in sourceFile.EnumeratePsiFiles(documentRange))
{
var t4File = file as IT4File;
if (t4File != null)
{
primaryFile = t4File;
}
else
{
secondaryFile = file;
}
}
return(Pair.Of(primaryFile, secondaryFile));
}
private void AddDirective([NotNull] IT4File t4File, [NotNull] IT4Directive directive)
{
Pair <IT4Directive, BeforeOrAfter> anchor = directive.FindAnchor(t4File.GetDirectives().ToArray(), _directiveInfoManager);
if (anchor.First != null)
{
if (anchor.Second == BeforeOrAfter.Before)
{
t4File.AddDirectiveBefore(directive, anchor.First);
}
else
{
t4File.AddDirectiveAfter(directive, anchor.First);
}
}
else
{
t4File.AddDirective(directive);
}
}
public T4CSharpCodeGenerationIntermediateResult Collect([NotNull] IT4File file)
{
var projectFile = file.PhysicalPsiSourceFile.ToProjectFile();
if (projectFile == null)
{
return(new T4CSharpCodeGenerationIntermediateResult(file, Interrupter));
}
Results.Push(new T4CSharpCodeGenerationIntermediateResult(file, Interrupter));
Guard.StartProcessing(file.LogicalPsiSourceFile.GetLocation());
file.ProcessDescendants(this);
string suffix = Result.State.ProduceBeforeEof();
if (!string.IsNullOrEmpty(suffix))
{
AppendTransformation(suffix, Result.State.FirstNode);
}
Guard.EndProcessing();
return(Results.Pop());
}
public ISelectedRange GetSelectedRange(IPsiSourceFile sourceFile, DocumentRange documentRange)
{
Pair <IT4File, IFile> pair = GetFiles(sourceFile, documentRange);
IT4File t4File = pair.First;
IFile codeBehindFile = pair.Second;
if (t4File == null)
{
return(null);
}
ITreeNode t4Node = t4File.FindNodeAt(documentRange);
if (t4Node == null)
{
return(null);
}
// if the current selection is inside C# code, use the C# extend selection directly
if (codeBehindFile != null)
{
ISelectEmbracingConstructProvider codeBehindProvider = PsiShared.GetComponent <PsiProjectFileTypeCoordinator>()
.GetByPrimaryPsiLanguageType(codeBehindFile.Language)
.SelectNotNull(fileType => Shell.Instance.GetComponent <IProjectFileTypeServices>().TryGetService <ISelectEmbracingConstructProvider>(fileType))
.FirstOrDefault();
if (codeBehindProvider != null)
{
ISelectedRange codeBehindRange = codeBehindProvider.GetSelectedRange(sourceFile, documentRange);
if (codeBehindRange != null)
{
return(new T4CodeBehindWrappedSelection(t4File, codeBehindRange));
}
}
}
return(new T4NodeSelection(t4File, t4Node));
}
public static string GetTargetExtension([NotNull] this IT4File file)
{
if (file == null)
{
throw new ArgumentNullException(nameof(file));
}
var extension = T4DirectiveInfoManager.Output.ExtensionAttribute;
string targetExtension = file
.GetThisAndChildrenOfType <IT4OutputDirective>()
.FirstOrDefault()
?.GetFirstAttribute(extension)
?.Value
.GetText();
if (targetExtension == null)
{
return(DefaultTargetExtension);
}
return(targetExtension.StartsWith(".", StringComparison.Ordinal)
? targetExtension.Substring(1)
: targetExtension);
}
public static PsiLanguageType GetLanguageType([CanBeNull] IT4File file)
{
string name = file
?.Blocks
.OfType <IT4TemplateDirective>()
.FirstOrDefault()
?.GetFirstAttribute(Template.LanguageAttribute)
?.Value
?.GetText();
switch (name)
{
case null:
case LanguageAttributeInfo.CSharpLanguageAttributeValue:
case LanguageAttributeInfo.NewCSharpLanguageAttributeValue:
return(CSharpLanguage.Instance);
case LanguageAttributeInfo.VBLanguageAttributeValue:
return(VBLanguage.Instance);
default:
return(UnknownLanguage.Instance);
}
}
private void CreateOrUpdateData([NotNull] IT4File t4File)
{
IPsiSourceFile sourceFile = t4File.GetSourceFile();
if (sourceFile == null || !sourceFile.LanguageType.Is <T4ProjectFileType>())
{
return;
}
var newData = new T4FileData(t4File, _directiveInfoManager);
T4FileData existingData;
lock (_fileDataBySourceFile) {
_fileDataBySourceFile.TryGetValue(sourceFile, out existingData);
_fileDataBySourceFile[sourceFile] = newData;
}
T4FileDataDiff diff = newData.DiffWith(existingData);
if (diff != null)
{
_fileDataChanged.Fire(Pair.Of(sourceFile, diff));
}
}
/// <summary>
/// Initializes a new instance of the <see cref="T4DaemonStageProcess"/> class.
/// </summary>
/// <param name="file">The associated T4 file.</param>
/// <param name="daemonProcess">The associated daemon process.</param>
protected T4DaemonStageProcess([NotNull] IT4File file, [NotNull] IDaemonProcess daemonProcess)
{
File = file;
DaemonProcess = daemonProcess;
}
private FileSystemPath GetTemporaryTargetFileFolder([NotNull] IT4File file) => GetTemporaryExecutableLocation(file).Parent;
public FileSystemPath GetExpectedTemporaryTargetFileLocation(IT4File file) => GetTemporaryExecutableLocation(file).Parent.Combine(GetExpectedTargetFileName(file));
protected override IDaemonStageProcess CreateProcess(IDaemonProcess process, IT4File file) {
return new T4ErrorProcess(file, process, _directiveInfoManager);
}
public T4CodeStructureRootElement(IT4File file)
: base(file) {
}
public T4CodeBehindWrappedSelection([NotNull] IT4File file, [NotNull] ISelectedRange codeBehindRange) {
_file = file;
_codeBehindRange = codeBehindRange;
}
private IProjectFile GetOrCreateSameDestinationFile(
[NotNull] IProjectModelTransactionCookie cookie,
[NotNull] IT4File file,
[NotNull] FileSystemPath temporary
) => GetOrCreateSameDestinationFile(cookie, file, temporary.Name);
protected override IDaemonStageProcess CreateProcess(IDaemonProcess process, IT4File file)
{
return(new T4HighlightingProcess(file, process));
}
protected override IDaemonStageProcess CreateProcess(IDaemonProcess process, IT4File file)
{
return new T4HighlightingProcess(file, process);
}
public T4CSharpIntermediateConverter(
[NotNull] T4CSharpCodeGenerationIntermediateResult intermediateResult,
[NotNull] IT4File file
) : base(intermediateResult, file)
{
}
protected override IDaemonStageProcess CreateProcess(
IDaemonProcess process,
IT4File file,
IContextBoundSettingsStore settings
) => new T4IncludeAwareDaemonProcess(file, process);
/// <summary>
/// Initializes a new instance of the <see cref="T4DaemonStageProcess"/> class.
/// </summary>
/// <param name="file">The associated T4 file.</param>
/// <param name="daemonProcess">The associated daemon process.</param>
/// <param name="directiveInfoManager">An instance of <see cref="DirectiveInfoManager"/>.</param>
public T4ErrorProcess([NotNull] IT4File file, [NotNull] IDaemonProcess daemonProcess, [NotNull] DirectiveInfoManager directiveInfoManager)
: base(file, daemonProcess)
{
_directiveInfoManager = directiveInfoManager;
}
private void Preprocess([NotNull] IT4File file, [NotNull] ISolution solution)
{
Statistics.TrackAction(T4StatisticIdBundle.PreprocessSilently);
solution.GetComponent <IT4TemplatePreprocessingManager>().TryPreprocess(file);
}
/// <summary>
/// Initializes a new instance of the <see cref="T4CSharpCodeGenerator"/> class.
/// </summary>
/// <param name="file">The associated T4 file whose C# code behind will be generated.</param>
/// <param name="directiveInfoManager">An instance of <see cref="DirectiveInfoManager"/>.</param>
internal T4CSharpCodeGenerator([NotNull] IT4File file, [NotNull] DirectiveInfoManager directiveInfoManager)
{
_file = file;
_directiveInfoManager = directiveInfoManager;
}
public T4CSharpCodeBehindGenerator(
[NotNull] IT4File file,
[NotNull] ISolution solution
) : base(file) => Solution = solution;
/// <summary>
/// Initializes a new instance of the <see cref="T4DaemonStageProcess"/> class.
/// </summary>
/// <param name="file">The associated T4 file.</param>
/// <param name="daemonProcess">The associated daemon process.</param>
protected T4DaemonStageProcess([NotNull] IT4File file, [NotNull] IDaemonProcess daemonProcess)
{
_file = file;
_daemonProcess = daemonProcess;
}
