public T4OutsideSolutionSourceFile(IProjectFileExtensions projectFileExtensions,
PsiProjectFileTypeCoordinator projectFileTypeCoordinator, IPsiModule module, FileSystemPath path,
Func<PsiSourceFileFromPath, bool> validityCheck, Func<PsiSourceFileFromPath, IPsiSourceFileProperties> propertiesFactory,
DocumentManager documentManager, IModuleReferenceResolveContext resolveContext)
: base(projectFileExtensions, projectFileTypeCoordinator, module, path, validityCheck, propertiesFactory, documentManager, resolveContext)
{
}
public static IDeclaredType CreateTypeByCLRName(string typeName, IPsiModule psiModule, IModuleReferenceResolveContext moduleReferenceResolveContext)
{
#if R10
return TypeFactory.CreateTypeByCLRName(typeName, psiModule);
#else
return TypeFactory.CreateTypeByCLRName(typeName, psiModule, moduleReferenceResolveContext);
#endif
}
public static bool TryGetTypeElement(string typeName, IPsiModule psiModule, IModuleReferenceResolveContext moduleReferenceResolveContext, out ITypeElement typeElement)
{
typeElement = null;
var typeByClrName = CreateTypeByCLRName(typeName, psiModule, moduleReferenceResolveContext);
if (typeByClrName != null)
{
typeElement = typeByClrName.GetTypeElement();
}
return typeElement != null;
}
public bool ReferenceModuleWithType(IPsiModule module, ITypeElement typeToReference, IModuleReferenceResolveContext resolveContext)
{
return(ReferenceModule(module, typeToReference.Module));
}
private static IEnumerable <ExceptionContent> GetExceptions([NotNull] IDeclaredElement element, [NotNull] PsiLanguageType languageType,
[NotNull] IPsiModule psiModule, [NotNull] IModuleReferenceResolveContext resolveContext)
{
XmlNode xmlDoc = element.GetXMLDoc(true);
if (xmlDoc == null)
{
return(EmptyList <ExceptionContent> .InstanceList);
}
XmlNodeList exceptionNodes = xmlDoc.SelectNodes("exception");
if (exceptionNodes == null || exceptionNodes.Count == 0)
{
return(EmptyList <ExceptionContent> .InstanceList);
}
var exceptions = new LocalList <ExceptionContent>();
foreach (XmlNode exceptionNode in exceptionNodes)
{
ExceptionContent exceptionContent = TryExtractException(exceptionNode as XmlElement, languageType, psiModule, resolveContext);
if (exceptionContent != null)
{
exceptions.Add(exceptionContent);
}
}
return(exceptions.ResultingList());
}
private VirtualFileSystemPath Resolve(
AssemblyReferenceTarget target,
IProject project,
IModuleReferenceResolveContext resolveContext
) => ResolveManager.Resolve(target, project, resolveContext)?.AssemblyPhysicalPath;
private IAttribute createAttributeDeclaration(ITypeElement attributeType, string fixedParamValue, string namedParamName, string namedParamValue, IPsiModule psiModule, IModuleReferenceResolveContext resolveContext, IAttribute originalAttribute)
{
var fixedArguments = createFixedArguments(fixedParamValue, psiModule, resolveContext);
var namedArguments = createNamedArguments(namedParamName, namedParamValue, psiModule, resolveContext, originalAttribute);
var elementFactory = CSharpElementFactory.GetInstance(psiModule);
var attributeDeclaration = elementFactory.CreateAttribute(attributeType, fixedArguments, namedArguments);
return(attributeDeclaration);
}
IEnumerable <IPsiModuleReference> IPsiModule.GetReferences(
IModuleReferenceResolveContext moduleReferenceResolveContext)
{
return(EmptyList <IPsiModuleReference> .Instance);
}
public static bool TryGetModelAttributeTypeElement(IPsiModule psiModule, IModuleReferenceResolveContext moduleReferenceResolveContext, out ITypeElement typeElement)
{
return TypeHelper.TryGetTypeElement(ModelAttribute, psiModule, moduleReferenceResolveContext, out typeElement);
}
public static bool TryGetAdvancedPropertyChangedEventArgsTypeElement(IPsiModule psiModule, IModuleReferenceResolveContext moduleReferenceResolveContext, out ITypeElement typeElement)
{
return TypeHelper.TryGetTypeElement(AdvancedPropertyChangedEventArgs, psiModule, moduleReferenceResolveContext, out typeElement);
}
public IEnumerable <IPsiModuleReference> GetReferences(IModuleReferenceResolveContext moduleReferenceResolveContext)
{
return(GetReferences());
}
public static bool TryGetArgumentTypeElement(IPsiModule psiModule, IModuleReferenceResolveContext moduleReferenceResolveContext, out ITypeElement typeElement)
{
return TypeHelper.TryGetTypeElement(Argument, psiModule, moduleReferenceResolveContext, out typeElement);
}
public static bool TryGetPropertyDataTypeElement(IPsiModule psiModule, IModuleReferenceResolveContext moduleReferenceResolveContext, out ITypeElement typeElement)
{
return TypeHelper.TryGetTypeElement(PropertyData, psiModule, moduleReferenceResolveContext, out typeElement);
}
public bool CanReferenceModule(IPsiModule module, IPsiModule moduleToReference, IModuleReferenceResolveContext context)
{
return(CanReferenceModule(module, moduleToReference));
}
private static ExceptionContent TryExtractException([CanBeNull] XmlElement exceptionElement, [NotNull] PsiLanguageType languageType,
[NotNull] IPsiModule psiModule, IModuleReferenceResolveContext resolveContext) {
if (exceptionElement == null)
return null;
string cref = exceptionElement.GetAttribute("cref");
if (String.IsNullOrEmpty(cref))
return null;
cref = XmlDocPresenterUtil.ProcessCref(cref);
if (String.IsNullOrEmpty(cref))
return null;
var exceptionContent = new ExceptionContent { Exception = cref };
if (exceptionElement.HasChildNodes) {
RichText richText = XmlDocRichTextPresenter.Run(exceptionElement, false, languageType, psiModule, resolveContext).RichText;
if (!richText.IsNullOrEmpty())
exceptionContent.Description = richText;
}
return exceptionContent;
}
// This is the ReSharper 8.2 version. 'context' has a default value of null
public RichTextBlock GetElementDescription(IDeclaredElement element, DeclaredElementDescriptionStyle style,
PsiLanguageType language, IPsiModule module, IModuleReferenceResolveContext context)
{
return(GetElementDescription(element, style, language, module));
}
private static ExceptionContent TryExtractException([CanBeNull] XmlElement exceptionElement, [NotNull] PsiLanguageType languageType,
[NotNull] IPsiModule psiModule, IModuleReferenceResolveContext resolveContext)
{
if (exceptionElement == null)
{
return(null);
}
string cref = exceptionElement.GetAttribute("cref");
if (String.IsNullOrEmpty(cref))
{
return(null);
}
cref = XmlDocPresenterUtil.ProcessCref(cref);
if (String.IsNullOrEmpty(cref))
{
return(null);
}
var exceptionContent = new ExceptionContent {
Exception = cref
};
if (exceptionElement.HasChildNodes)
{
RichText richText = XmlDocRichTextPresenter.Run(exceptionElement, false, languageType, psiModule, resolveContext).RichText;
if (!richText.IsNullOrEmpty())
{
exceptionContent.Description = richText;
}
}
return(exceptionContent);
}
public static ITypeElement GetDataObjectBaseTypeElement(IPsiModule psiModule, IModuleReferenceResolveContext moduleReferenceResolveContext)
{
ITypeElement result;
TryGetDataObjectBaseTypeElement(psiModule, moduleReferenceResolveContext, out result);
return result;
}
private static AttributeValue[] createFixedArguments(string fixedParamValue, IPsiModule psiModule, IModuleReferenceResolveContext resolveContext)
{
var fixedArguments = fixedParamValue != null
? new[] { new AttributeValue(new ConstantValue(fixedParamValue, psiModule, resolveContext)) }
: new AttributeValue[0];
return(fixedArguments);
}
public IEnumerable<IPsiModuleReference> GetReferences(IModuleReferenceResolveContext moduleReferenceResolveContext)
{
return GetReferences();
}
private FileSystemPath Resolve(
AssemblyReferenceTarget target,
IProject project,
IModuleReferenceResolveContext resolveContext
) => ResolveManager.Resolve(target, project, resolveContext);
// This is the ReSharper 8.2 version. 'context' has a default value of null
public RichTextBlock GetElementDescription(IDeclaredElement element, DeclaredElementDescriptionStyle style,
PsiLanguageType language, IPsiModule module, IModuleReferenceResolveContext context)
{
return GetElementDescription(element, style, language, module);
}
public bool CanReferenceModule([NotNull] IPsiModule module, [CanBeNull] IPsiModule moduleToReference, IModuleReferenceResolveContext context)
{
return moduleReferencer.CanReferenceModule(module, moduleToReference);
}
public bool CanReferenceModule(IPsiModule module, IPsiModule moduleToReference, IModuleReferenceResolveContext context)
{
return CanReferenceModule(module, moduleToReference);
}
public static bool TryGetViewModelBaseTypeElement(IPsiModule psiModule, IModuleReferenceResolveContext moduleReferenceResolveContext, out ITypeElement typeElement)
{
return TypeHelper.TryGetTypeElement(ViewModelBase, psiModule, moduleReferenceResolveContext, out typeElement);
}
private Pair <string, AttributeValue>[] createNamedArguments(string namedParamName, string namedParamValue, IPsiModule psiModule, IModuleReferenceResolveContext resolveContext, IAttribute originalAttribute)
{
if (namedParamName == null && (originalAttribute == null || originalAttribute.PropertyAssignments.Count == 0))
{
return(new Pair <string, AttributeValue> [0]);
}
var result = originalAttribute != null
? convertOriginalPropertyAssignments(namedParamName, originalAttribute)
: Enumerable.Empty <Pair <string, AttributeValue> >();
if (namedParamName != null)
{
result = result.Concat(
new[]
{
new Pair <string, AttributeValue>(
namedParamName,
new AttributeValue(new ConstantValue(namedParamValue, psiModule, resolveContext)))
});
}
return(result.ToArray());
}
/// <summary>
/// Gets all modules referenced by this module.
/// </summary>
/// <returns>All referenced modules.</returns>
public IEnumerable<IPsiModuleReference> GetReferences(IModuleReferenceResolveContext moduleReferenceResolveContext)
{
_shellLocks.AssertReadAccessAllowed();
var references = new PsiModuleReferenceAccumulator(TargetFrameworkId);
foreach (IAssemblyCookie cookie in _assemblyReferences.Values) {
if (cookie.Assembly == null)
continue;
IPsiModule psiModule = _psiModules.GetPrimaryPsiModule(cookie.Assembly, TargetFrameworkId);
// Normal assembly.
if (psiModule != null)
references.Add(new PsiModuleReference(psiModule));
// Assembly that is the output of a current project: reference the project instead.
else {
IProject project = _outputAssemblies.GetProjectByOutputAssembly(cookie.Assembly);
if (project != null) {
psiModule = _psiModules.GetPrimaryPsiModule(project, TargetFrameworkId);
if (psiModule != null)
references.Add(new PsiModuleReference(psiModule));
}
}
}
return references.GetReferences();
}
public bool CanReferenceModule([NotNull] IPsiModule module, [CanBeNull] IPsiModule moduleToReference, IModuleReferenceResolveContext context)
{
return(moduleReferencer.CanReferenceModule(module, moduleToReference));
}
public bool ReferenceModuleWithType(IPsiModule module, ITypeElement typeToReference, IModuleReferenceResolveContext resolveContext)
{
return ReferenceModuleWithType(module, typeToReference);
}
private static ITypeElement getAttributeType(IPsiModule psiModule, IModuleReferenceResolveContext resolveContext, string attributeName)
{
return(TypeElementUtil.GetTypeElementByClrName(new ClrTypeName(attributeName), psiModule, resolveContext));
}
