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)); }