public BasedOnRegistration(ITreeNode registrationRootElement, ITypeElement basedOnElement, IEnumerable<WithServiceRegistration> withServices)
: base(registrationRootElement, withServices)
{
this.basedOnElement = basedOnElement;
name = basedOnElement.GetClrName().FullName;
}
public ContextElement CreateContext(ITypeElement type)
{
if (_cache.Classes.ContainsKey(type))
{
return(_cache.Classes[type]);
}
var context = GetOrCreateContextElement(_provider,
#if RESHARPER_61
_manager,
_psiModuleManager,
_cacheManager,
#endif
_project,
_projectEnvoy,
#if RESHARPER_6
type.GetClrName().FullName,
#else
type.CLRName,
#endif
_assemblyPath,
type.GetSubjectString(),
type.GetTags(),
type.IsIgnored());
#if RESHARPER_6
foreach (var child in context.Children)
{
child.State = UnitTestElementState.Pending;
}
#endif
_cache.Classes.Add(type, context);
return(context);
}
public override string ToString()
{
string displayName = Implementation != null?Implementation.GetClrName().FullName
: serviceType.GetClrName().FullName;
return(string.Format("Implemented by: {0}", displayName));
}
private static void FixQualifierExpression([NotNull] ITextControl textControl, [NotNull] ICSharpExpression expression, [NotNull] ITypeElement ownerType)
{
var qualifierRange = expression.GetDocumentRange().TextRange;
var comparer = DeclaredElementEqualityComparer.TypeElementComparer;
// do not produce type qualifier when static method from containing type completed
var typeDeclaration = expression.GetContainingTypeDeclaration();
if (typeDeclaration != null && comparer.Equals(typeDeclaration.DeclaredElement, ownerType))
{
var reference = ReferenceExpressionNavigator.GetByQualifierExpression(expression).NotNull("reference != null");
var delimiter = reference.Delimiter;
if (delimiter != null)
{
qualifierRange = qualifierRange.JoinRight(delimiter.GetDocumentRange().TextRange);
}
textControl.Document.ReplaceText(qualifierRange, string.Empty);
}
else
{
var keyword = CSharpTypeFactory.GetTypeKeyword(ownerType.GetClrName());
textControl.Document.ReplaceText(qualifierRange, keyword ?? "T");
}
}
public BasedOnRegistration(ITreeNode registrationRootElement, ITypeElement basedOnElement)
: base(registrationRootElement)
{
this.basedOnElement = basedOnElement;
name = basedOnElement.GetClrName().FullName;
}
public ContextElement CreateContext(ITypeElement type)
{
if (_cache.Classes.ContainsKey(type))
{
return _cache.Classes[type];
}
var context = GetOrCreateContextElement(_provider,
#if RESHARPER_61
_manager,
_psiModuleManager,
_cacheManager,
#endif
_project,
_projectEnvoy,
type.GetClrName().FullName,
_assemblyPath,
type.GetSubjectString(),
type.GetTags(),
type.IsIgnored());
foreach (var child in context.Children)
{
child.State = UnitTestElementState.Pending;
}
_cache.Classes.Add(type, context);
return context;
}
private MethodSignature[] GetExpectedMethodSignatures(ITypeElement attributeTypeElement,
PredefinedType predefinedType)
{
var attributeClrName = attributeTypeElement.GetClrName();
if (myMethodSignatures.TryGetValue(attributeClrName, out var signatures))
{
if (signatures.All(s => s.IsValid()))
{
return(signatures);
}
// If any of the signatures are no longer valid, clear the cache and try again
myMethodSignatures.Clear();
}
// Try to get the expected signature from a method marked with RequiredSignatureAttribute (introduced in
// Unity 2017.3). If the attribute does not exist, either because it's not applied, or we're on an earlier
// version, check our known attributes for a signature
// Remember that we're run on pooled threads, so try to add to the concurrent dictionary. It doesn't matter
// if another thread beats us.
signatures = GetSignaturesFromRequiredSignatureAttribute(attributeTypeElement)
?? GetSignaturesFromKnownAttributes(attributeClrName, predefinedType);
if (signatures != null)
{
myMethodSignatures.TryAdd(attributeClrName.GetPersistent(), signatures);
}
return(signatures);
}
public static string GetFullClrName([NotNull] this ITypeElement typeElement)
{
if (typeElement == null)
{
throw new ArgumentNullException("typeElement");
}
return(typeElement.GetClrName().FullName);
}
public static bool IsEnumerableClass([CanBeNull] this ITypeElement type)
{
if (type == null)
{
return(false);
}
var typeName = type.GetClrName();
return(typeName.Equals(PredefinedType.ENUMERABLE_CLASS));
}
public override bool IsSatisfiedBy(ITypeElement typeElement)
{
var attributesOwner = typeElement as IAttributesOwner;
if (attributesOwner == null)
{
return(false);
}
return(attributesOwner.HasAttributeInstance(attributeType.GetClrName(), true));
}
private static string GetDisplayName(ITypeElement element)
{
IClrTypeName clrName = element.GetClrName();
string fullName = string.Format("{0}.{1}", clrName.GetNamespaceName(), clrName.ShortName);
if (element.HasTypeParameters())
{
fullName = string.Format("{0}<>", fullName);
}
return fullName;
}
private static void GetPossibleSourceNames(ITypeElement type, ISet <string> names)
{
names.Add(type.ShortName);
var typeShortName = type.ShortName;
names.Add(typeShortName.SubstringBeforeLast(AttributeInstanceExtensions.ATTRIBUTE_SUFFIX));
names.Add(typeShortName.SubstringBeforeLast(FSharpImplUtil.ModuleSuffix));
if (type.GetClrName().TryGetPredefinedAbbreviations(out var abbreviations))
{
names.AddRange(abbreviations);
}
}
// NOTE: This method assumes that the type is not a descendant of UnityEngine.Object!
private bool IsSerializableType([CanBeNull] ITypeElement type, [NotNull] IProject project, bool isTypeUsage,
bool hasSerializeReference = false)
{
if (!(type is IStruct || type is IClass))
{
return(false);
}
if (isTypeUsage)
{
// Type usage (e.g. field declaration) is stricter. Means it must be a concrete type with no type
// parameters, unless the type usage is for [SerializeReference], which allows abstract types
if (type is IModifiersOwner modifiersOwner && modifiersOwner.IsAbstract && !hasSerializeReference)
{
return(false);
}
// Unity 2020.1 allows fields to have generic types. It's currently undocumented, but there are no
// limitations on the number of type parameters, or even nested type parameters. The base type needs to
// be serializable, but type parameters don't (if a non-serializable type parameter is used as a field,
// it just isn't serialised).
// https://blogs.unity3d.com/2020/03/17/unity-2020-1-beta-is-now-available-for-feedback/
var unityVersion = myUnityVersion.GetActualVersion(project);
if (unityVersion < new Version(2020, 1) && type is ITypeParametersOwner typeParametersOwner &&
typeParametersOwner.TypeParameters.Count > 0)
{
return(false);
}
}
if (type is IClass @class && @class.IsStaticClass())
{
return(false);
}
// System.Dictionary is special cased and excluded. We can see this in UnitySerializationLogic.cs in the
// reference source repo. It also excludes anything with a full name beginning "System.", which includes
// "System.Version" (which is marked [Serializable]). However, it doesn't exclude string, int, etc.
// TODO: Rewrite this whole section to properly mimic UnitySerializationLogic.cs
var name = type.GetClrName();
if (Equals(name, KnownTypes.SystemVersion) || Equals(name, PredefinedType.GENERIC_DICTIONARY_FQN))
{
return(false);
}
using (CompilationContextCookie.GetExplicitUniversalContextIfNotSet())
return(type.HasAttributeInstance(PredefinedType.SERIALIZABLE_ATTRIBUTE_CLASS, true));
}
private static void GetPossibleSourceNames(ITypeElement type, ISet <string> names)
{
names.Add(type.ShortName);
var typeShortName = type.ShortName;
if (typeShortName.EndsWith(FSharpImplUtil.AttributeSuffix))
{
names.Add(typeShortName.SubstringBeforeLast(FSharpImplUtil.AttributeSuffix, StringComparison.Ordinal));
}
if (type.GetClrName().TryGetAbbreviations(out var abbreviations))
{
names.AddRange(abbreviations);
}
}
// NOTE: This method assumes that the type is not a descendant of UnityEngine.Object!
private bool IsSerializableType([CanBeNull] ITypeElement type, [NotNull] IProject project, bool isTypeUsage)
{
if (!(type is IStruct || type is IClass))
{
return(false);
}
if (isTypeUsage)
{
// Type usage (e.g. field declaration) is stricter. Means it must be a concrete type with no type
// parameters
if (type is IModifiersOwner modifiersOwner && modifiersOwner.IsAbstract)
{
return(false);
}
// Unity 2020.1 allows fields to have generic types. It's currently undocumented, but there are no
// limitations on the number of type parameters, or even nested type parameters. The base type needs to
// be serializable, but type parameters don't (if a non-serializable type parameter is used as a field,
// it just isn't serialised).
// https://blogs.unity3d.com/2020/03/17/unity-2020-1-beta-is-now-available-for-feedback/
var unityVersion = myUnityVersion.GetActualVersion(project);
if (unityVersion < new Version(2020, 1) && type is ITypeParametersOwner typeParametersOwner &&
typeParametersOwner.TypeParameters.Count > 0)
{
return(false);
}
}
if (type is IClass @class && @class.IsStaticClass())
{
return(false);
}
// System.Version seems to be special cased. In Mono, it's marked as [Serializable], but in netstandard,
// it's not. Which means that depending on what runtime you're using, you could potentially get different
// fields serialised. However, it never shows up in Inspector, so it's a good indication that it's handled
// specially.
if (Equals(type.GetClrName(), KnownTypes.SystemVersion))
{
return(false);
}
return(type.HasAttributeInstance(PredefinedType.SERIALIZABLE_ATTRIBUTE_CLASS, true));
}
private void CheckCommonCostlyMethods([NotNull] IInvocationExpression invocationExpressionParam, [NotNull] HotMethodAnalyzerContext context,
[NotNull] IClrDeclaredElement declaredElement, [NotNull] ITypeElement containingType, [NotNull] IReference reference)
{
ISet <string> knownCostlyMethods = null;
var clrTypeName = containingType.GetClrName();
if (clrTypeName.Equals(KnownTypes.Component))
{
knownCostlyMethods = ourKnownComponentCostlyMethods;
}
if (clrTypeName.Equals(KnownTypes.GameObject))
{
knownCostlyMethods = ourKnownGameObjectCostlyMethods;
}
if (clrTypeName.Equals(KnownTypes.Resources))
{
knownCostlyMethods = ourKnownResourcesCostlyMethods;
}
if (clrTypeName.Equals(KnownTypes.Object))
{
knownCostlyMethods = ourKnownObjectCostlyMethods;
}
if (clrTypeName.Equals(KnownTypes.Transform))
{
knownCostlyMethods = ourKnownTransformCostlyMethods;
}
if (knownCostlyMethods == null)
{
return;
}
var shortName = declaredElement.ShortName;
if (knownCostlyMethods.Contains(shortName))
{
context.MarkCurrentAsCostlyReachable();
myConsumer.AddHighlighting(new PerformanceCriticalCodeInvocationHighlighting(reference));
}
}
private static string GetAssemblyQualifiedName(this ITypeElement type,
ISubstitution substitution,
IDictionary <DeclaredElementInstance, IName> seenElements)
{
if (type == null)
{
return(Names.UnknownType.Identifier);
}
var clrTypeName = type.GetClrName();
var containingModule = type.Module.ContainingProjectModule;
Asserts.NotNull(containingModule, "module is null");
var moduleName = containingModule.GetQualifiedName();
var typeParameters = type.GetTypeParametersList(substitution, seenElements);
string myName;
var parent = type.GetContainingType();
var myFullName = clrTypeName.FullName;
if (parent != null)
{
var parentName = parent.GetName <ITypeName>(substitution);
// including the generic `N ticks
var parentFullName = parentName.FullName;
// shortName does not include the generic `N ticks, so we have to find it in the fullname...
var startOfShortName = myFullName.LastIndexOf("+", StringComparison.Ordinal) + 1;
// ... and ignore the leading part
var fullShortName = myFullName.Substring(startOfShortName);
myName = string.Format("{0}+{1}", parentFullName, fullShortName);
}
else
{
myName = myFullName;
}
return(string.Format(
"{0}{1}, {2}",
myName,
typeParameters,
moduleName));
}
public ContextElement CreateContext(ITypeElement type)
{
if (_cache.Classes.ContainsKey(type))
{
return _cache.Classes[type];
}
ContextElement context = new ContextElement(_provider,
_projectEnvoy,
#if RESHARPER_6
type.GetClrName().FullName,
#else
type.CLRName,
#endif
_assemblyPath,
type.GetSubjectString(),
type.GetTags(),
type.IsIgnored());
_cache.Classes.Add(type, context);
return context;
}
protected override bool IsReferenceExpressionNotRelated([NotNull] IReferenceExpression currentReference,
IClrDeclaredElement currentElement, ITypeElement currentContainingType)
{
if (base.IsReferenceExpressionNotRelated(currentReference, currentElement, currentContainingType))
{
return(true);
}
if (!currentContainingType.GetClrName().Equals(KnownTypes.Transform))
{
return(true);
}
if (ourTransformConflicts.ContainsKey(DeclaredElement.ShortName))
{
var conflicts = ourTransformConflicts[DeclaredElement.ShortName];
return(!conflicts.Contains(currentElement.ShortName));
}
return(true);
}
public IModule GetTargetModule <T>(T element)
{
var referenceExpression = element as IReferenceExpression;
if (referenceExpression == null)
{
return(null);
}
if (referenceExpression.Reference.GetName() == "ThisAssembly")
{
IResolveResult resolveResult = referenceExpression.Reference.Resolve().Result;
IDeclaredElement declaredElement = resolveResult.DeclaredElement;
if (declaredElement == null)
{
return(null);
}
var property = declaredElement as IProperty;
if (property == null)
{
return(null);
}
ITypeElement propertyType = property.GetContainingType();
if (propertyType == null)
{
return(null);
}
if (!propertyType.GetClrName().Equals(autofacModuleName))
{
return(null);
}
return(referenceExpression.GetPsiModule().ContainingProjectModule);
}
return(null);
}
public IModule GetTargetModule <T>(T element)
{
var referenceExpression = element as IReferenceExpression;
if (referenceExpression == null)
{
return(null);
}
if (referenceExpression.Reference.GetName() == methodName)
{
IResolveResult resolveResult = referenceExpression.Reference.Resolve().Result;
IDeclaredElement declaredElement = resolveResult.DeclaredElement;
if (declaredElement == null)
{
return(null);
}
var clrDeclaredElement = declaredElement as IClrDeclaredElement;
if (clrDeclaredElement == null)
{
return(null);
}
ITypeElement clrType = clrDeclaredElement.GetContainingType();
if (clrType == null)
{
return(null);
}
if (!clrType.GetClrName().Equals(clrTypeName))
{
return(null);
}
return(referenceExpression.GetPsiModule().ContainingProjectModule);
}
return(null);
}
public ContextElement CreateContext(ITypeElement type)
{
var context = GetOrCreateContext(_provider,
_manager,
_psiModuleManager,
_cacheManager,
_project,
_projectEnvoy,
type.GetClrName().GetPersistent(),
_assemblyPath,
type.GetSubjectString(),
type.GetTags(),
type.IsIgnored());
foreach (var child in context.Children)
{
child.State = UnitTestElementState.Pending;
}
_cache.Contexts.Add(type, context);
return context;
}
public ContextElement CreateContext(ITypeElement type)
{
var context = GetOrCreateContext(_provider,
_manager,
_psiModuleManager,
_cacheManager,
_project,
_projectEnvoy,
type.GetClrName().GetPersistent(),
_assemblyPath,
type.GetSubjectString(),
type.GetTags(),
type.IsIgnored());
foreach (var child in context.Children)
{
child.State = UnitTestElementState.Pending;
}
_cache.Contexts.Add(type, context);
return(context);
}
public static IClrTypeName GetClassNameAppropriateToLocation(ISolution solution, ITextControl textControl)
{
IDeclaredElement documentElement = TextControlToPsi.GetContainingTypeOrTypeMember(solution, textControl);
if (documentElement == null)
{
return(FindFirstTypeInFile(solution, textControl.Document));
}
//AppendLineToOutputWindow("Element at cursor is of type " + documentElement.GetType().Name);
IClrTypeName clrTypeName = null;
if (documentElement is IClass @class)
{
clrTypeName = @class.GetClrName();
}
if (documentElement is ITypeElement element && clrTypeName == null)
{
ITypeElement containingType = element.GetContainingType();
if (containingType != null)
{
clrTypeName = containingType.GetClrName();
}
}
if (clrTypeName == null)
{
AppendLineToOutputWindow(solution.Locks, "Unable to identify the class from current cursor position.");
return(FindFirstTypeInFile(solution, textControl.Document));
}
return(clrTypeName);
}
// I always have to think about what this means...
// Based on Type.IsAssignableFrom(c)
// "Determines whether an instance of the current Type can be assigned from an instance of the specified Type"
// True if c and the current type are the same type, or if the current type is in the inheritance hierarchy of
// the type c
// In other words, type.IsAssignableFrom(c) is true if I can assign an instance of c to a variable of type "type"
internal static bool IsAssignableFrom(this Type type, ITypeElement c)
{
return(type.FullName == c.GetClrName().FullName || c.GetAllSuperTypes().Any(superType => type.FullName == c.GetClrName().FullName));
}
private static bool IsRootType(ITypeElement type)
{
var fn = type.GetClrName().FullName;
return("System.Object".Equals(fn) || "System.ValueType".Equals(fn) || "System.Enum".Equals(fn));
}
public CommonType GetCommonType(ITypeElement type)
{
var clrTypeName = type.GetClrName();
return(new CommonType(clrTypeName.ShortName, clrTypeName.FullName, type.GetImplementedTypes().Select(x => x.GetClrName().FullName)));
}
public static bool IsInSystemLikeNamespace([NotNull] this ITypeElement typeElement) => typeElement.GetClrName().NamespaceNames.FirstOrDefault() == "System";
// I always have to think about what this means...
// Based on Type.IsAssignableFrom(c)
// "Determines whether an instance of the current Type can be assigned from an instance of the specified Type"
// True if c and the current type are the same type, or if the current type is in the inheritance hierarchy of
// the type c
// In other words, type.IsAssignableFrom(c) is true if I can assign an instance of c to a variable of type "type"
internal static bool IsAssignableFrom(this Type type, ITypeElement c)
{
return type.FullName == c.GetClrName().FullName || c.GetAllSuperTypes().Any(superType => type.FullName == c.GetClrName().FullName);
}
public static ClassReference GetClassReference(this ITypeElement typeElement)
{
return(new ClassReference(new ClassId(typeElement.GetClrName().FullName)));
}
private XunitTestClassElement GetOrCreateClassElement(ITypeElement testClass, IProject projectElement, ProjectModelElementEnvoy projectEnvoy)
{
ITypeElement containingType = testClass.GetContainingType();
XunitTestClassElement parent = null;
if (containingType != null)
parent = GetParent(containingType);
return factory.GetOrCreateClassElement(testClass.GetClrName(), projectElement, projectEnvoy, parent);
}
private XunitTestClassElement GetParent(ITypeElement containingType)
{
var typeName = containingType.GetClrName().GetPersistent();
var id = typeName.FullName;
return factory.GetElementById(project, id) as XunitTestClassElement;
}
static bool IsPredefinedTypeElement([CanBeNull] ITypeElement typeElement, [NotNull] IClrTypeName clrName) => typeElement != null && typeElement.GetClrName().Equals(clrName);
public CommonType GetCommonType(ITypeElement type)
{
var clrTypeName = type.GetClrName();
return new CommonType(clrTypeName.ShortName, clrTypeName.FullName, type.GetImplementedTypes().Select(x => x.GetClrName().FullName));
}
private static bool IsEnumerable(ITypeElement type)
{
var typeName = type.GetClrName();
return(typeName.Equals(PredefinedType.ENUMERABLE_CLASS));
}
