protected override void DoRegisterCallbacks(
ProjectModelViewHost host,
DteProtocolModel model
)
{
MapWithAstManager <ITypeDeclaration, ITypeElement, List <CodeElementModel> >(
model.CodeElement_get_Bases,
node => GetSuperTypes(node.DeclaredElement).AsList(),
element => GetSuperTypes(element).AsList(),
type => new List <CodeElementModel>
{
ToModel(TypeFactory.CreateTypeByCLRName("System.Array", type.Module))
}
);
MapWithAstManager <ICSharpTypeDeclaration, ITypeElement, CodeElementModel>(
model.CodeElement_get_Namespace,
CreateNamespaceModel,
element => ToModel(element.GetContainingNamespace()),
type => throw new NotImplementedException()
);
IEnumerable <CodeElementModel> GetSuperTypes(ITypeElement declaredType) =>
from typeElement in declaredType.NotNull().GetSuperTypeElements()
where typeElement != null
let child = ToModel(typeElement)
where child != null
select child;
}
public LambdaPsiHost(Lifetime lifetime, ISolution solution, ISymbolCache symbolCache, PsiIconManager psiIconManager, IconHost iconHost,
ProjectModelViewHost projectModelViewHost, IShellLocks locks, ILogger logger)
{
_symbolCache = symbolCache;
_psiIconManager = psiIconManager;
_iconHost = iconHost;
_projectModelViewHost = projectModelViewHost;
_locks = locks;
_logger = logger;
var model = solution.GetProtocolSolution().GetLambdaPsiModel();
model.DetermineHandlersRequest.Advise(lifetime, request =>
{
var handlers = DetermineHandlers(solution);
model.DetermineHandlersResponse(new DetermineHandlersResponse(request.RequestId, handlers));
});
model.IsHandlerExistRequest.Advise(lifetime, request =>
{
var className = request.ClassName;
var methodName = request.MethodName;
var projectId = request.ProjectId;
var handlerExists = IsHandlerExists(lifetime, projectId, className, methodName);
model.IsHandlerExistResponse(new HandlerExistResponse(request.RequestId, handlerExists));
});
}
public void RegisterCallbacks(
AstManager astManager,
ISolution solution,
ProjectModelViewHost host,
DteProtocolModel model
)
{
model.FileCodeModel_get_CodeElements.SetWithReadLock(projectItemModel =>
{
var projectFile = host.GetItemById <IProjectFile>(projectItemModel.Id);
var psiFile = projectFile
?.ToSourceFile()
?.GetPrimaryPsiFile();
if (psiFile == null)
{
return(new List <CodeElementModel>());
}
var query =
from child in psiFile.GetEnvDTEModelChildren()
let childId = astManager.GetOrCreateId(child)
let childTypeId = PsiElementRegistrar.GetTypeId(child)
select new CodeElementModel(childTypeId, childId);
return(query.ToList());
});
}
public LambdaPsiHost(ISolution solution, ISymbolCache symbolCache, PsiIconManager psiIconManager, IconHost iconHost,
ProjectModelViewHost projectModelViewHost, IShellLocks locks, ILogger logger)
{
_symbolCache = symbolCache;
_psiIconManager = psiIconManager;
_iconHost = iconHost;
_projectModelViewHost = projectModelViewHost;
_locks = locks;
_logger = logger;
var model = solution.GetProtocolSolution().GetLambdaPsiModel();
model.DetermineHandlers.Set((lifetime, unit) =>
{
var task = new RdTask <List <HandlerCompletionItem> >();
task.Set(DetermineHandlers(solution));
return(task);
});
model.IsHandlerExists.Set((lifetime, request) =>
{
var task = new RdTask <bool>();
var className = request.ClassName;
var methodName = request.MethodName;
var projectId = request.ProjectId;
var handlerExists = IsHandlerExists(lifetime, projectId, className, methodName);
task.Set(handlerExists);
return(task);
});
}
public void RegisterCallbacks(
AstManager astManager,
ISolution solution,
ProjectModelViewHost host,
DteProtocolModel model
)
{
model.Solution_FileName.SetWithReadLock(() => solution.SolutionFilePath.FullPath);
model.Solution_Count.SetWithReadLock(() => solution.GetAllProjects().Count);
model.Solution_Item.SetWithReadLock(index =>
{
var projects = solution.GetAllProjects();
if (projects.Count < index)
{
return(new Rider.Model.ProjectModel(-1));
}
var project = projects.ElementAt(index - 1);
int id = host.GetIdByItem(project);
return(new Rider.Model.ProjectModel(id));
});
model.Solution_get_Projects.SetWithReadLock(() => solution
.GetAllProjects()
.Select(host.GetIdByItem)
.Where(id => id != 0)
.Select(id => new Rider.Model.ProjectModel(id))
.AsList());
}
public void RegisterCallbacks(
AstManager astManager,
ISolution solution,
ProjectModelViewHost host,
DteProtocolModel model
)
{
model.ProjectItem_get_Name.SetWithReadLock(projectItemModel =>
host.GetItemById <IProjectItem>(projectItemModel.Id)?.Name ?? "");
model.ProjectItem_set_Name.SetWithReadLock(request =>
{
var item = host.GetItemById <IProjectItem>(request.Model.Id);
if (item == null)
{
return(Unit.Instance);
}
solution.InvokeUnderTransaction(cookie => cookie.Rename(item, request.NewName));
return(Unit.Instance);
});
model.ProjectItem_get_Kind.SetWithReadLock(projectItemModel =>
host.GetItemById <IProjectItem>(projectItemModel.Id)?.Kind switch
{
ProjectItemKind.PHYSICAL_FILE => ProjectItemKindModel.PhysicalFile,
ProjectItemKind.PHYSICAL_DIRECTORY => ProjectItemKindModel.PhysicalFolder,
ProjectItemKind.PROJECT => ProjectItemKindModel.Project,
ProjectItemKind.VIRTUAL_DIRECTORY => ProjectItemKindModel.VirtualDirectory,
_ => ProjectItemKindModel.Unknown,
});
protected override void DoRegisterCallbacks(
ProjectModelViewHost host,
DteProtocolModel model
)
{
MapWithAstManager(
model.CodeElement_get_Children,
node => node.GetEnvDTEModelChildren().Select(CreateCodeElementModel).ToList(),
element => throw new NotImplementedException(),
type => throw new InvalidOperationException()
);
MapWithAstManager(
model.CodeElement_get_Access,
GetAccessRights,
GetAccessRights,
type => throw new NotImplementedException());
MapWithAstManager(
model.CodeElement_get_Name,
ElementNameProvider.FindName,
element => element.ShortName,
type => type.GetPresentableName(CSharpLanguage.Instance.NotNull())
);
MapWithAstManager(
model.CodeElement_get_FullName,
node =>
{
if (!(node is ICSharpDeclaration declaration))
{
return(null);
}
return(CSharpSharedImplUtil.GetQualifiedName(declaration));
},
public void RegisterCallbacks(
AstManager astManager,
ISolution solution,
ProjectModelViewHost host,
DteProtocolModel model
)
{
model.Project_get_Name.SetWithReadLock(projectModel => host.GetItemById <IProject>(projectModel.Id)?.Name ?? "");
model.Project_set_Name.SetWithReadLock(request =>
{
string name = request.NewName;
var project = host.GetItemById <IProject>(request.Model.Id);
if (project == null)
{
return(Unit.Instance);
}
solution.InvokeUnderTransaction(cookie => cookie.Rename(project, name));
return(Unit.Instance);
});
model.Project_get_FileName.SetWithReadLock(projectModel =>
host.GetItemById <IProject>(projectModel.Id)?.ProjectFile?.Name ?? "");
model.Project_Delete.SetWithReadLock(projectModel =>
{
var project = host.GetItemById <IProject>(projectModel.Id);
if (project == null)
{
return(Unit.Instance);
}
solution.InvokeUnderTransaction(cookie => cookie.Remove(project));
return(Unit.Instance);
});
}
private T4FileLocation GetT4FileLocation([NotNull] IT4File file)
{
var sourceFile = file.PhysicalPsiSourceFile.NotNull();
var projectFile = sourceFile.ToProjectFile().NotNull();
int id = ProjectModelViewHost.GetIdByItem(projectFile);
return(new T4FileLocation(id));
}
protected override void DoRegisterCallbacks(ProjectModelViewHost host, DteProtocolModel model)
{
MapWithAstManager <IParameterDeclaration, IParameter, CodeElementModel>(
model.CodeParameter_get_Type,
node => ToModel(node.DeclaredElement.NotNull().Type),
parameter => ToModel(parameter.Type),
type => throw new InvalidOperationException()
);
}
protected override void DoRegisterCallbacks(ProjectModelViewHost host, DteProtocolModel model)
{
MapWithAstManager <IFunctionDeclaration, IFunction, CodeElementModel>(
model.CodeFunction_get_Type,
node => ToModel(node.DeclaredElement.NotNull().ReturnType),
function => ToModel(function.ReturnType),
type => throw new InvalidOperationException()
);
}
public void RegisterCallbacks(
AstManager astManager,
ISolution solution,
ProjectModelViewHost host,
DteProtocolModel model
)
{
AstManager = astManager;
DoRegisterCallbacks(host, model);
}
public void RegisterCallbacks(
AstManager astManager,
ISolution solution,
ProjectModelViewHost host,
DteProtocolModel model
)
{
model.DTE_Name.SetWithReadLock(() => "JetBrains Rider");
model.DTE_FileName.SetWithReadLock(() => FileSystemPath
.Parse(AppDomain.CurrentDomain.BaseDirectory)
.Combine(AppDomain.CurrentDomain.FriendlyName)
.FullPath
);
model.DTE_CommandLineArgs.SetWithReadLock(() => Environment.GetCommandLineArgs().AggregateString(" "));
}
public T4TemplateExecutionManager(
Lifetime lifetime,
[NotNull] ISolution solution,
[NotNull] ProjectModelViewHost projectModelViewHost,
[NotNull] NotificationsModel notificationsModel,
[NotNull] ILogger logger,
[NotNull] IT4ProjectModelTemplateMetadataManager templateMetadataManager,
[NotNull] RiderBackgroundTaskHost backgroundTaskHost
)
{
Lifetime = lifetime;
Solution = solution;
ProjectModelViewHost = projectModelViewHost;
NotificationsModel = notificationsModel;
Logger = logger;
TemplateMetadataManager = templateMetadataManager;
BackgroundTaskHost = backgroundTaskHost;
Model = solution.GetProtocolSolution().GetT4ProtocolModel();
RunningFiles = new Dictionary <FileSystemPath, LifetimeDefinition>();
}
public T4ProtocolModelManager(
[NotNull] ISolution solution,
[NotNull] IT4TargetFileManager targetFileManager,
[NotNull] IT4TemplateCompiler compiler,
[NotNull] IT4BuildMessageConverter converter,
[NotNull] IT4ModelInteractionHelper helper,
[NotNull] IT4TemplateExecutionManager executionManager,
[NotNull] ILogger logger,
[NotNull] ProjectModelViewHost host,
[NotNull] IT4ProjectReferenceResolver projectReferenceResolver
)
{
Solution = solution;
TargetFileManager = targetFileManager;
Compiler = compiler;
Converter = converter;
ExecutionManager = executionManager;
Logger = logger;
ProjectReferenceResolver = projectReferenceResolver;
Host = host;
var model = solution.GetProtocolSolution().GetT4ProtocolModel();
RegisterCallbacks(model, helper);
}
public T4ModelInteractionHelper([NotNull] ProjectModelViewHost host, [NotNull] ILogger logger)
{
Host = host;
Logger = logger;
}
protected abstract void DoRegisterCallbacks(
[NotNull] ProjectModelViewHost host,
[NotNull] DteProtocolModel model
);
